Python Language
Métodos de cuerda

Sintaxis

• str.capitalize () -> str
• str.casefold () -> str [solo para Python> 3.3]
• str.center (ancho [, fillchar]) -> str
• str.count (sub [, start [, end]]) -> int
• str.decode (encoding = "utf-8" [, errores]) -> unicode [solo en Python 2.x]
• str.encode (codificación = "utf-8", errores = "estricto") -> bytes
• str.endswith (sufijo [, inicio [, final]]) -> bool
• str.expandtabs (tabsize = 8) -> str
• str.find (sub [, start [, end]]) -> int
• str.format (* args, ** kwargs) -> str
• str.format_map (mapeo) -> str
• str.index (sub [, start [, end]]) -> int
• str.isalnum () -> bool
• str.isalpha () -> bool
• str.isdecimal () -> bool
• str.isdigit () -> bool
• identificador str. () -> bool
• str.islower () -> bool
• str.isnumeric () -> bool
• str.isprintable () -> bool
• str.isspace () -> bool
• str.istitle () -> bool
• str.isupper () -> bool
• str.join (iterable) -> str
• str.ljust (ancho [, fillchar]) -> str
• str.lower () -> str
• str.lstrip ([caracteres]) -> str
• str.maketrans estático (x [, y [, z]])
• str.partition (sep) -> (head, sep, tail)
• str.replace (antiguo, nuevo [, cuenta]) -> str
• str.rfind (sub [, start [, end]]) -> int
• str.rindex (sub [, inicio [, final]]) -> int
• str.rjust (ancho [, fillchar]) -> str
• str.rpartition (sep) -> (head, sep, tail)
• str.rsplit (sep = None, maxsplit = -1) -> lista de cadenas
• str.rstrip ([caracteres]) -> str
• str.split (sep = None, maxsplit = -1) -> lista de cadenas
• str.splitlines ([keepends]) -> lista de cadenas
• str.startswith (prefijo [, inicio [, final]]) -> libro
• str.strip ([caracteres]) -> str
• str.swapcase () -> str
• str.title () -> str
• str.translate (tabla) -> str
• str.upper () -> str
• str.zfill (ancho) -> str

Observaciones

Cambiar la capitalización de una cadena

El tipo de cadena de Python proporciona muchas funciones que actúan sobre la capitalización de una cadena. Éstos incluyen :

• str.casefold
• str.upper
• str.lower
• str.capitalize
• str.title
• str.swapcase

Con cadenas de Unicode (el valor predeterminado en Python 3), estas operaciones no son asignaciones 1: 1 o reversibles. La mayoría de estas operaciones están destinadas a fines de visualización, en lugar de a la normalización.

"XßΣ".casefold()
# 'xssσ'

"XßΣ".lower()
# 'xßς'

str.upper()

str.upper toma todos los caracteres de una cadena y los convierte a su equivalente en mayúsculas, por ejemplo:

"This is a 'string'.".upper()
# "THIS IS A 'STRING'."

str.lower()

str.lower hace lo contrario; toma todos los caracteres de una cadena y los convierte a su equivalente en minúsculas:

"This IS a 'string'.".lower()
# "this is a 'string'."

str.capitalize()

str.capitalize devuelve una versión en mayúscula de la cadena, es decir, hace que el primer carácter tenga mayúsculas y el resto sea inferior:

"this Is A 'String'.".capitalize() # Capitalizes the first character and lowercases all others
# "This is a 'string'."

str.title()

str.title devuelve el título de la versión de la cadena, es decir, todas las letras al principio de una palabra están en mayúsculas y las demás en minúsculas:

"this Is a 'String'".title()
# "This Is A 'String'"

str.swapcase()

str.swapcase devuelve un nuevo objeto de cadena en el que todos los caracteres en minúsculas se cambian a mayúsculas y todos los caracteres en mayúsculas a inferiores:

"this iS A STRiNG".swapcase() #Swaps case of each character
# "THIS Is a strIng"

Uso como métodos de clase str

Vale la pena señalar que estos métodos pueden llamarse en objetos de cadena (como se muestra arriba) o como un método de clase de la clase str (con una llamada explícita a str.upper , etc.)

str.upper("This is a 'string'")
# "THIS IS A 'STRING'"

Esto es más útil cuando se aplica uno de estos métodos a muchas cadenas a la vez, por ejemplo, una función de map .

map(str.upper,["These","are","some","'strings'"])
# ['THESE', 'ARE', 'SOME', "'STRINGS'"]

Dividir una cadena basada en un delimitador en una lista de cadenas

str.split(sep=None, maxsplit=-1)

str.split toma una cadena y devuelve una lista de subcadenas de la cadena original. El comportamiento difiere dependiendo de si el argumento sep se proporciona u omite.

Si no se proporciona sep , o es None , entonces la división tiene lugar donde hay espacios en blanco. Sin embargo, los espacios en blanco iniciales y finales se ignoran, y varios caracteres de espacios en blanco consecutivos se tratan igual que un solo espacio en blanco:

>>> "This is a sentence.".split()
['This', 'is', 'a', 'sentence.']

>>> " This is    a sentence.  ".split()
['This', 'is', 'a', 'sentence.']

>>> "            ".split()
[]

El parámetro sep se puede usar para definir una cadena delimitadora. La cadena original se divide donde se produce la cadena delimitadora, y el propio delimitador se descarta. Varios delimitadores consecutivos no se tratan de la misma manera que una sola ocurrencia, sino que hacen que se creen cadenas vacías.

>>> "This is a sentence.".split(' ')
['This', 'is', 'a', 'sentence.']

>>> "Earth,Stars,Sun,Moon".split(',')
['Earth', 'Stars', 'Sun', 'Moon']

>>> " This is    a sentence.  ".split(' ')
['', 'This', 'is', '', '', '', 'a', 'sentence.', '', '']

>>> "This is a sentence.".split('e')
['This is a s', 'nt', 'nc', '.']

>>> "This is a sentence.".split('en')
['This is a s', 't', 'ce.']

El valor predeterminado es dividir en cada aparición del delimitador, sin embargo, el parámetro maxsplit limita el número de divisiones que se producen. El valor predeterminado de -1 significa que no hay límite:

>>> "This is a sentence.".split('e', maxsplit=0)
['This is a sentence.']

>>> "This is a sentence.".split('e', maxsplit=1)
['This is a s', 'ntence.']

>>> "This is a sentence.".split('e', maxsplit=2)
['This is a s', 'nt', 'nce.']

>>> "This is a sentence.".split('e', maxsplit=-1)
['This is a s', 'nt', 'nc', '.']

str.rsplit(sep=None, maxsplit=-1)

str.rsplit ("división derecha") difiere de str.split ("división izquierda") cuando se especifica maxsplit . La división comienza al final de la cadena en lugar de al principio:

>>> "This is a sentence.".rsplit('e', maxsplit=1)
['This is a sentenc', '.']

>>> "This is a sentence.".rsplit('e', maxsplit=2)
['This is a sent', 'nc', '.']

Nota : Python especifica el número máximo de divisiones realizadas, mientras que la mayoría de los otros lenguajes de programación especifican el número máximo de subcadenas creadas. Esto puede crear confusión al portar o comparar código.

Reemplace todas las ocurrencias de una subcadena por otra subcadena

El tipo str de Python también tiene un método para reemplazar las ocurrencias de una subcadena con otra subcadena en una cadena dada. Para casos más exigentes, uno puede usar re.sub .

str.replace(old, new[, count]) :

str.replace toma dos argumentos old y new que contiene el old sub-secuencia que va a ser reemplazado por el new sub-secuencia. El count argumentos opcional especifica el número de reemplazos que se realizarán:

Por ejemplo, para reemplazar 'foo' con 'spam' en la siguiente cadena, podemos llamar a str.replace con old = 'foo' y new = 'spam' :

>>> "Make sure to foo your sentence.".replace('foo', 'spam')
"Make sure to spam your sentence."

Si la cadena dada contiene múltiples ejemplos que coinciden con el old argumento, todas las apariciones se reemplazan por el valor suministrado en new :

>>> "It can foo multiple examples of foo if you want.".replace('foo', 'spam')
"It can spam multiple examples of spam if you want."

A menos que, por supuesto, proporcionemos un valor para el count . En este caso, las ocurrencias de count serán reemplazadas:

>>> """It can foo multiple examples of foo if you want, \
... or you can limit the foo with the third argument.""".replace('foo', 'spam', 1)
'It can spam multiple examples of foo if you want, or you can limit the foo with the third argument.'

str.format y f-strings: formatea valores en una cadena

Python proporciona interpolación de cadenas y funcionalidad de formato a través de la función str.format , introducida en la versión 2.6 y f-cadenas introducidas en la versión 3.6.

Dadas las siguientes variables:

i = 10
f = 1.5
s = "foo"
l = ['a', 1, 2]
d = {'a': 1, 2: 'foo'}

Las siguientes afirmaciones son todas equivalentes

"10 1.5 foo ['a', 1, 2] {'a': 1, 2: 'foo'}"

>>> "{} {} {} {} {}".format(i, f, s, l, d)

>>> str.format("{} {} {} {} {}", i, f, s, l, d)

>>> "{0} {1} {2} {3} {4}".format(i, f, s, l, d)

>>> "{0:d} {1:0.1f} {2} {3!r} {4!r}".format(i, f, s, l, d)

>>> "{i:d} {f:0.1f} {s} {l!r} {d!r}".format(i=i, f=f, s=s, l=l, d=d)

>>> f"{i} {f} {s} {l} {d}"

>>> f"{i:d} {f:0.1f} {s} {l!r} {d!r}"

Para referencia, Python también admite calificadores de estilo C para el formato de cadenas. Los ejemplos a continuación son equivalentes a los anteriores, pero se prefieren las versiones de str.format debido a los beneficios en flexibilidad, consistencia de notación y extensibilidad:

"%d %0.1f %s %r %r" % (i, f, s, l, d)

"%(i)d %(f)0.1f %(s)s %(l)r %(d)r" % dict(i=i, f=f, s=s, l=l, d=d)

Las llaves que se usan para la interpolación en str.format de str.format también se pueden numerar para reducir la duplicación al formatear cadenas. Por ejemplo, los siguientes son equivalentes:

"I am from Australia. I love cupcakes from Australia!"

>>> "I am from {}. I love cupcakes from {}!".format("Australia", "Australia")

>>> "I am from {0}. I love cupcakes from {0}!".format("Australia")

Si bien la documentación oficial de Python es, como es habitual, lo suficientemente exhaustiva, pyformat.info tiene un gran conjunto de ejemplos con explicaciones detalladas.

Además, los caracteres { y } pueden escaparse utilizando corchetes dobles:

"{'a': 5, 'b': 6}"

>>> "{{'{}': {}, '{}': {}}}".format("a", 5, "b", 6)

>>> f"{{'{'a'}': {5}, '{'b'}': {6}}"

Consulte Formato de cadena para obtener información adicional. str.format() se propuso en PEP 3101 y f-strings en PEP 498 .

Contando el número de veces que una subcadena aparece en una cadena

Hay un método disponible para contar el número de apariciones de una str.count en otra cadena, str.count .

str.count(sub[, start[, end]])

str.count devuelve un int indica el número de apariciones no superpuestas de la str.count sub en otra cadena. Los argumentos opcionales start y end indican el principio y el final en el que se realizará la búsqueda. De forma predeterminada, start = 0 y end = len(str) significa que se buscará en toda la cadena:

>>> s = "She sells seashells by the seashore."
>>> s.count("sh")
2
>>> s.count("se")
3
>>> s.count("sea")
2
>>> s.count("seashells")
1

Al especificar un valor diferente para el start , al end , podemos obtener una búsqueda más localizada y contar, por ejemplo, si el start es igual a 13 la llamada a:

>>> s.count("sea", start)
1

es equivalente a:

>>> t = s[start:]
>>> t.count("sea")
1

Prueba los caracteres iniciales y finales de una cadena.

Para probar el principio y el final de una cadena dada en Python, uno puede usar los métodos str.startswith() y str.endswith() .

str.startswith(prefix[, start[, end]])

Como su nombre lo indica, str.startswith se usa para probar si una cadena dada comienza con los caracteres dados en el prefix .

>>> s = "This is a test string"
>>> s.startswith("T")
True
>>> s.startswith("Thi")
True
>>> s.startswith("thi")  
False

Los argumentos opcionales de start y end especifican los puntos de inicio y finalización a partir de los cuales se iniciarán y finalizarán las pruebas. En el siguiente ejemplo, al especificar un valor de inicio de 2 , se buscará nuestra cadena desde la posición 2 y después:

>>> s.startswith("is", 2)
True

Esto da como resultado True desde s[2] == 'i' y s[3] == 's' .

También puede usar una tuple para verificar si comienza con alguna de un conjunto de cadenas

>>> s.startswith(('This', 'That'))
True
>>> s.startswith(('ab', 'bc'))
False

str.endswith(prefix[, start[, end]])

str.endswith es exactamente similar a str.startswith la única diferencia es que busca caracteres finales y no caracteres iniciales. Por ejemplo, para probar si una cadena termina en una parada completa, se podría escribir:

>>> s = "this ends in a full stop."
>>> s.endswith('.')
True
>>> s.endswith('!')
False

al igual que con startswith se pueden usar más de un carácter como secuencia final:

>>> s.endswith('stop.')
True
>>> s.endswith('Stop.')
False

También puede usar una tuple para verificar si termina con cualquiera de un conjunto de cadenas

>>> s.endswith(('.', 'something'))
True
>>> s.endswith(('ab', 'bc'))
False

Probando de qué está compuesta una cuerda

El tipo str de Python también presenta una serie de métodos que se pueden usar para evaluar el contenido de una cadena. Estos son str.isalpha , str.isdigit , str.isalnum , str.isspace . La capitalización se puede probar con str.isupper , str.islower y str.istitle .

str.isalpha

str.isalpha no toma argumentos y devuelve True si todos los caracteres de una cadena dada son alfabéticos, por ejemplo:

>>> "Hello World".isalpha()  # contains a space
False
>>> "Hello2World".isalpha()  # contains a number
False
>>> "HelloWorld!".isalpha()  # contains punctuation
False
>>> "HelloWorld".isalpha()
True

Como un caso de borde, la cadena vacía se evalúa como False cuando se usa con "".isalpha() .

str.isupper , str.islower , str.istitle

Estos métodos prueban el uso de mayúsculas en una cadena dada.

str.isupper es un método que devuelve True si todos los caracteres de una cadena dada están en mayúsculas y False caso contrario.

>>> "HeLLO WORLD".isupper()
False
>>> "HELLO WORLD".isupper()
True
>>> "".isupper()
False

A la inversa, str.islower es un método que devuelve True si todos los caracteres de una cadena dada son minúsculas y False contrario.

>>> "Hello world".islower()
False
>>> "hello world".islower()
True
>>> "".islower()
False

str.istitle devuelve True si la cadena dada es un título cargado; es decir, cada palabra comienza con un carácter en mayúscula seguido de caracteres en minúscula.

>>> "hello world".istitle()
False
>>> "Hello world".istitle()
False
>>> "Hello World".istitle()
True
>>> "".istitle()
False

str.isdecimal , str.isdigit , str.isnumeric

str.isdecimal devuelve si la cadena es una secuencia de dígitos decimales, adecuada para representar un número decimal.

str.isdigit incluye dígitos que no están en una forma adecuada para representar un número decimal, como los dígitos en superíndice.

str.isnumeric incluye cualquier valor numérico, incluso si no son dígitos, como valores fuera del rango 0-9.

            isdecimal    isdigit   isnumeric

12345        True        True       True
១2߃໔5        True        True       True
①²³🄅₅       False       True       True
⑩⒓          False       False      True
Five         False       False      False

Bytestrings ( bytes en Python 3, str en Python 2), solo admite isdigit , que solo verifica los dígitos ASCII básicos.

Al igual que con str.isalpha , la cadena vacía se evalúa como False .

str.isalnum

Esta es una combinación de str.isalpha y str.isnumeric , específicamente se evalúa como True si todos los caracteres en la cadena dada son alfanuméricos , es decir, consisten en caracteres alfabéticos o numéricos:

>>> "Hello2World".isalnum()
True
>>> "HelloWorld".isalnum()
True
>>> "2016".isalnum()
True
>>> "Hello World".isalnum()  # contains whitespace
False

str.isspace

Se evalúa como True si la cadena solo contiene caracteres de espacio en blanco.

>>> "\t\r\n".isspace()
True
>>> " ".isspace()
True

A veces, una cadena se ve "vacía" pero no sabemos si es porque solo contiene espacios en blanco o ningún carácter.

>>> "".isspace()
False

Para cubrir este caso necesitamos una prueba adicional.

>>> my_str = ''
>>> my_str.isspace()
False
>>> my_str.isspace() or not my_str
True

Pero la forma más corta de probar si una cadena está vacía o simplemente contiene caracteres de espacio en blanco es usar la strip (sin argumentos elimina todos los caracteres de espacio en blanco iniciales y finales)

>>> not my_str.strip()
True

str.translate: Traducir caracteres en una cadena

Python admite un método de translate en el tipo str que le permite especificar la tabla de traducción (utilizada para los reemplazos), así como cualquier carácter que deba eliminarse en el proceso.

str.translate(table[, deletechars])

El método maketrans ( str.maketrans en Python 3 y string.maketrans en Python 2) le permite generar una tabla de traducción.

>>> translation_table = str.maketrans("aeiou", "12345")
>>> my_string = "This is a string!"
>>> translated = my_string.translate(translation_table)
'Th3s 3s 1 str3ng!'

El método de translate devuelve una cadena que es una copia traducida de la cadena original.

Puede establecer el argumento de la table en None si solo necesita eliminar caracteres.

>>> 'this syntax is very useful'.translate(None, 'aeiou')
'ths syntx s vry sfl'

Eliminar caracteres iniciales / finales no deseados de una cadena

Se proporcionan tres métodos que ofrecen la posibilidad de eliminar los caracteres str.strip y finales de una cadena: str.strip , str.rstrip y str.lstrip . Los tres métodos tienen la misma firma y los tres devuelven un nuevo objeto de cadena con caracteres no deseados eliminados.

str.strip([chars])

str.strip actúa sobre una cadena dada y elimina (elimina) cualquier carácter str.strip o final contenido en los chars argumento; Si no se suministran chars o es None , todos los caracteres de espacios en blanco se eliminan de forma predeterminada. Por ejemplo:

>>> "    a line with leading and trailing space     ".strip() 
'a line with leading and trailing space'

Si se proporcionan chars , todos los caracteres contenidos en él se eliminan de la cadena, que se devuelve. Por ejemplo:

>>> ">>> a Python prompt".strip('> ')  # strips '>' character and space character 
'a Python prompt'

str.rstrip([chars]) y str.lstrip([chars])

Estos métodos tienen una semántica y argumentos similares con str.strip() , su diferencia radica en la dirección desde la que comienzan. str.rstrip() comienza desde el final de la cadena, mientras que str.lstrip() divide desde el principio de la cadena.

Por ejemplo, usando str.rstrip :

>>> "     spacious string      ".rstrip()
'     spacious string'

Mientras, usando str.lstrip :

>>> "     spacious string      ".rstrip()
'spacious string      '

Comparaciones de cadenas insensibles al caso

La comparación de cadenas en una forma que no distingue entre mayúsculas y minúsculas parece algo trivial, pero no lo es. Esta sección solo considera las cadenas Unicode (la predeterminada en Python 3). Tenga en cuenta que Python 2 puede tener debilidades sutiles en relación con Python 3; el manejo de Unicode de este último es mucho más completo.

Lo primero que hay que tener en cuenta es que las conversiones de eliminación de casos en Unicode no son triviales. Hay texto para el que text.lower() != text.upper().lower() , como "ß" :

>>> "ß".lower()
'ß'

>>> "ß".upper().lower()
'ss'

Pero digamos que quería comparar "BUSSE" y "Buße" . Demonios, es probable que también quieras comparar "BUSSE" y "BUẞE" iguales, esa es la forma de capital más nueva. La forma recomendada es usar casefold :

>>> help(str.casefold)
"""
Help on method_descriptor:

casefold(...)
      S.casefold() -> str
    
     Return a version of S suitable for caseless comparisons.
"""

No se limite a usar lower . Si la casefold no está disponible, hacer .upper().lower() ayuda (pero solo un poco).

Entonces deberías considerar los acentos. Si su procesador de fuentes es bueno, probablemente piense que "ê" == "ê" , pero no lo hace:

>>> "ê" == "ê"
False

Esto es porque en realidad son

>>> import unicodedata

>>> [unicodedata.name(char) for char in "ê"]
['LATIN SMALL LETTER E WITH CIRCUMFLEX']

>>> [unicodedata.name(char) for char in "ê"]
['LATIN SMALL LETTER E', 'COMBINING CIRCUMFLEX ACCENT']

La forma más sencilla de lidiar con esto es unicodedata.normalize . Probablemente desee utilizar la normalización NFKD , pero no dude en consultar la documentación. Entonces uno hace

>>> unicodedata.normalize("NFKD", "ê") == unicodedata.normalize("NFKD", "ê")
True

Para finalizar, aquí esto se expresa en funciones:

import unicodedata

def normalize_caseless(text):
    return unicodedata.normalize("NFKD", text.casefold())

def caseless_equal(left, right):
    return normalize_caseless(left) == normalize_caseless(right)

Unir una lista de cadenas en una cadena

Una cadena puede usarse como separador para unir una lista de cadenas en una sola cadena usando el método join() . Por ejemplo, puede crear una cadena en la que cada elemento de una lista esté separado por un espacio.

>>> " ".join(["once","upon","a","time"])
"once upon a time"

El siguiente ejemplo separa los elementos de cadena con tres guiones.

>>> "---".join(["once", "upon", "a", "time"])
"once---upon---a---time"

Constantes útiles del módulo de cadena

El módulo de string de Python proporciona constantes para operaciones relacionadas con cadenas. Para usarlos, importa el módulo de string :

>>> import string

string.ascii_letters :

Concatenación de ascii_lowercase y ascii_uppercase :

>>> string.ascii_letters
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'

string.ascii_lowercase

Contiene todos los caracteres ASCII en minúsculas:

>>> string.ascii_lowercase
'abcdefghijklmnopqrstuvwxyz'

string.ascii_uppercase :

Contiene todos los caracteres ASCII en mayúsculas:

>>> string.ascii_uppercase
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

string.digits :

Contiene todos los caracteres de dígitos decimales:

>>> string.digits
'0123456789'

string.hexdigits :

Contiene todos los caracteres de dígitos hexadecimales:

>>> string.hexdigits
'0123456789abcdefABCDEF'

string.octaldigits :

Contiene todos los caracteres de dígitos octales:

>>> string.octaldigits
'01234567'

string.punctuation :

Contiene todos los caracteres que se consideran puntuación en la configuración regional de C :

>>> string.punctuation
'!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'

string.whitespace :

Contiene todos los caracteres ASCII considerados espacios en blanco:

>>> string.whitespace
' \t\n\r\x0b\x0c'

En el modo de script, print(string.whitespace) imprimirá los caracteres reales, use str para obtener la cadena devuelta arriba.

string.printable :

Contiene todos los caracteres que se consideran imprimibles; una combinación de string.digits , string.ascii_letters , string.punctuation y string.whitespace .

>>> string.printable
'0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~ \t\n\r\x0b\x0c'

Invertir una cadena

Una cadena puede revertirse usando la función reversed() incorporada, que toma una cadena y devuelve un iterador en orden inverso.

>>> reversed('hello')
<reversed object at 0x0000000000000000>
>>> [char for char in reversed('hello')]
['o', 'l', 'l', 'e', 'h']

reversed() puede envolverse en una llamada a ''.join() para crear una cadena desde el iterador.

>>> ''.join(reversed('hello'))
'olleh'

Si bien el uso de reversed() puede ser más legible para los usuarios no iniciados de Python, el uso del corte extendido con un paso de -1 es más rápido y conciso. Aquí, intente implementarlo como función:

>>> def reversed_string(main_string):
...     return main_string[::-1]
...
>>> reversed_string('hello')
'olleh'

Justificar cuerdas

Python proporciona funciones para justificar cadenas, permitiendo el relleno de texto para que la alineación de varias cadenas sea mucho más fácil.

A continuación se muestra un ejemplo de str.ljust y str.rjust :

interstates_lengths = {
    5: (1381, 2222),
    19: (63, 102),
    40: (2555, 4112),
    93: (189,305),
}
for road, length in interstates_lengths.items():
    miles,kms = length
    print('{} -> {} mi. ({} km.)'.format(str(road).rjust(4), str(miles).ljust(4), str(kms).ljust(4)))

  40 -> 2555 mi. (4112 km.)
  19 -> 63   mi. (102  km.)
   5 -> 1381 mi. (2222 km.)
  93 -> 189  mi. (305  km.)

ljust y rjust son muy similares. Ambos tienen un parámetro de width y un parámetro de fillchar opcional. Cualquier cadena creada por estas funciones es al menos tan larga como el parámetro de width que se pasó a la función. Si la cadena es más larga que el width alread, no se trunca. El argumento fillchar , que por defecto es el carácter de espacio ' ' debe ser un solo carácter, no una cadena de caracteres múltiples.

La función ljust el final de la cadena con la que se llama con el fillchar hasta que tenga una width caracteres. La función rjust el principio de la cadena de una manera similar. Por lo tanto, l y r en los nombres de estas funciones se refieren al lado en el que la cadena original, no el fillchar , está posicionado en la cadena de salida.

Conversión entre str o bytes de datos y caracteres Unicode

El contenido de los archivos y mensajes de la red puede representar caracteres codificados. A menudo necesitan ser convertidos a Unicode para una visualización adecuada.

En Python 2, es posible que necesite convertir datos de str a caracteres Unicode. El valor predeterminado ( '' , "" , etc.) es una cadena ASCII, con cualquier valor fuera del rango ASCII mostrado como valores escapados. Las cadenas Unicode son u'' (o u"" , etc.).

# You get "© abc" encoded in UTF-8 from a file, network, or other data source

s = '\xc2\xa9 abc'  # s is a byte array, not a string of characters
                    # Doesn't know the original was UTF-8
                    # Default form of string literals in Python 2
s[0]                # '\xc2' - meaningless byte (without context such as an encoding)
type(s)             # str - even though it's not a useful one w/o having a known encoding

u = s.decode('utf-8')  # u'\xa9 abc'
                       # Now we have a Unicode string, which can be read as UTF-8 and printed properly
                       # In Python 2, Unicode string literals need a leading u
                       # str.decode converts a string which may contain escaped bytes to a Unicode string
u[0]                # u'\xa9' - Unicode Character 'COPYRIGHT SIGN' (U+00A9) '©'
type(u)             # unicode

u.encode('utf-8')   # '\xc2\xa9 abc'
                    # unicode.encode produces a string with escaped bytes for non-ASCII characters

En Python 3 es posible que necesite convertir matrices de bytes (denominadas 'literal de byte') a cadenas de caracteres Unicode. El valor predeterminado es ahora una cadena Unicode, y los literales de bytestring ahora deben ingresarse como b'' , b"" , etc. Un literal de byte devolverá True a isinstance(some_val, byte) , asumiendo que some_val es una cadena que podría estar codificada como bytes.

# You get from file or network "© abc" encoded in UTF-8

s = b'\xc2\xa9 abc' # s is a byte array, not characters
                    # In Python 3, the default string literal is Unicode; byte array literals need a leading b
s[0]                # b'\xc2' - meaningless byte (without context such as an encoding)
type(s)             # bytes - now that byte arrays are explicit, Python can show that.

u = s.decode('utf-8')  # '© abc' on a Unicode terminal
                       # bytes.decode converts a byte array to a string (which will, in Python 3, be Unicode)
u[0]                # '\u00a9' - Unicode Character 'COPYRIGHT SIGN' (U+00A9) '©'
type(u)             # str
                    # The default string literal in Python 3 is UTF-8 Unicode

u.encode('utf-8')   # b'\xc2\xa9 abc'
                    # str.encode produces a byte array, showing ASCII-range bytes as unescaped characters.

Cadena contiene

Python hace que sea extremadamente intuitivo comprobar si una cadena contiene una subcadena dada. Solo usa el operador in :

>>> "foo" in "foo.baz.bar"
True

Nota: probar una cadena vacía siempre resultará en True :

>>> "" in "test"
True