Strings en

Acerca de Strings

Un str en Python es una secuencia inmutable de puntos de código Unicode. Estos pueden incluir letras, signos diacríticos, caracteres de posicionamiento, números, símbolos de moneda, emoji, signos de puntuación, caracteres de espacio y de salto de línea, y mucho más.

Si quieres profundizar en qué información codifica un string (o, «¿cómo sabe una computadora cómo traducir ceros y unos a letras?»), esta entrada de blog sigue siendo de gran ayuda. La documentación de Python también ofrece un HOWTO de Unicode muy detallado que analiza el soporte de Python para la especificación de Unicode en los módulos str, bytes y re, consideraciones sobre configuraciones regionales y algunos problemas comunes con la codificación y la traducción.

Los strings implementan todas las operaciones comunes de secuencia y se pueden recorrer con la sintaxis for item in <str> o for index, item in enumerate(<str>). Se puede hacer referencia a puntos de código individuales (strings de longitud 1) mediante un 0-based index desde la izquierda, o un -1-based index desde la derecha.

Los strings se pueden concatenar con <str> + <other str> o <str>.join(<iterable>), y dividir con <str>.split(<separator>). También ofrecen varias opciones adicionales de formato, ensamblado y plantillas.

Un literal de tipo str se puede declarar con comillas simples ' o dobles ". El carácter de escape \ está disponible cuando se necesita.

>>> single_quoted = 'These allow "double quoting" without "escape" characters.'

>>> double_quoted = "These allow embedded 'single quoting', so you don't have to use an 'escape' character."

Los strings de varias líneas se declaran con ''' o """.

>>> triple_quoted = '''Three single quotes or "double quotes" in a row allow for multi-line string literals.
  Line break characters, tabs and other whitespace is fully supported. Remember - The escape "\" character is also available if needed (as can be seen below). 
  
  You\'ll most often encounter multi-line strings as "doc strings" or "doc tests" written just below the first line of a function or class definition.
    They\'re often used with auto documentation ✍ tools.
    '''

El constructor str(<object>) se puede usar para crear o convertir strings a partir de otros objetos:

>>> my_number = 42
>>> str(my_number)
...
"42"

Aunque el constructor str(<object>) se puede usar para convertir strings, no itera ni descompone un objeto. Esto es distinto del comportamiento de los constructores de otros tipos de datos como list(), set(), dict() o tuple(), y puede dar resultados sorprendentes.

>>> numbers = [1,3,5,7]
>>> str(numbers)
...
'[1,3,5,7]'

Se puede hacer referencia a los puntos de código dentro de un str con un 0-based index desde la izquierda:

creative = '창의적인'

>>> creative[0]
'창'

>>> creative[2]
'적'

>>> creative[3]
'인'

La indexación también funciona desde la derecha, empezando con un -1-based index:

creative = '창의적인'

>>> creative[-4]
'창'

>>> creative[-2]
'적'

>>> creative[-1]
'인'

No existe un tipo separado de «carácter» o «runa» en Python, así que indexar un string produce un nuevo str de longitud 1:

>>> website = "exercism"
>>> type(website[0])
<class 'str'>

>>> len(website[0])
1

>>> website[0] == website[0:1] == 'e'
True

Los substrings se pueden seleccionar mediante notación de rebanada, usando <str>[<start>:<stop>:<step>] para producir un nuevo string. Los resultados excluyen el índice stop. Si no se da un start, el índice inicial será 0. Si no se da un stop, el índice stop será el final del string.

moon_and_stars = '🌟🌟🌙🌟🌟⭐'

>>> moon_and_stars[1:4]
'🌟🌙🌟'

>>> moon_and_stars[:3]
'🌟🌟🌙'

>>> moon_and_stars[3:]
'🌟🌟⭐'

>>> moon_and_stars[:-1]
'🌟🌟🌙🌟🌟'

>>> moon_and_stars[:-3]
'🌟🌟🌙'

Los strings también se pueden dividir en strings más pequeños con <str>.split(<separator>), que devuelve una list de substrings. Usar <str>.split() sin ningún argumento divide el string en los espacios en blanco.

>>> cat_ipsum = "Destroy house in 5 seconds command the hooman."
>>> cat_ipsum.split()
...
['Destroy', 'house', 'in', '5', 'seconds', 'command', 'the', 'hooman.']


>>> cat_words = "feline, four-footed, ferocious, furry"
>>> cat_words.split(',')
...
['feline', ' four-footed', ' ferocious', ' furry']


>>> colors = """red,
orange,
green,
purple,
yellow"""

>>> colors.split(',\n')
['red', 'orange', 'green', 'purple', 'yellow']

Los strings se pueden concatenar con el operador +. Conviene usar este método con moderación, porque no es muy eficiente ni fácil de mantener.

language = "Ukrainian"
number = "nine"
word = "дев'ять"

sentence = word + " " + "means" + " " + number + " in " + language + "."

>>> print(sentence)
...
"дев'ять means nine in Ukrainian."

Si necesitas combinar una list, tuple, set u otra colección de strings individuales en un único str, <str>.join(<iterable>) es una mejor opción:

# str.join() makes a new string from the iterables elements.
>>> chickens = ["hen", "egg", "rooster"] # Lists are iterable.
>>> ' '.join(chickens)
'hen egg rooster'

# Any string can be used as the joining element.
>>> ' :: '.join(chickens)
'hen :: egg :: rooster'

>>> ' 🌿 '.join(chickens)
'hen 🌿 egg 🌿 rooster'


# Any iterable can be used as input.
>>> flowers = ("rose", "daisy", "carnation")  # Tuples are iterable.
>>> '*-*'.join(flowers)
'rose*-*daisy*-*carnation'

>>> flowers = {"rose", "daisy", "carnation"}  # Sets are iterable, but output order is not guaranteed.
>>> '*-*'.join(flowers)
'rose*-*carnation*-*daisy'

>>> phrase = "This is my string"  # Strings are iterable, but be careful!
>>> '..'.join(phrase)
'T..h..i..s.. ..i..s.. ..m..y.. ..s..t..r..i..n..g'


# Separators are inserted **between** elements, but can be any string (including spaces).
# This can be exploited for interesting effects.
>>> under_words = ['under', 'current', 'sea', 'pin', 'dog', 'lay']
>>> separator = ' ⤴️ under' # Note the leading space, but no trailing space.
>>> separator.join(under_words)
'under ⤴️ undercurrent ⤴️ undersea ⤴️ underpin ⤴️ underdog ⤴️ underlay'

# The separator can be composed different ways, as long as the result is a string.
>>> upper_words = ['upper', 'crust', 'case', 'classmen', 'most', 'cut']
>>> separator = ' 🌟 ' + upper_words[0] # This becomes one string, similar to ' ⤴️ under'.
>>> separator.join(upper_words)
 'upper 🌟 uppercrust 🌟 uppercase 🌟 upperclassmen 🌟 uppermost 🌟 uppercut'

Los strings admiten todas las operaciones comunes de secuencia. Se puede recorrer cada punto de código en un bucle con for item in <str>. Se pueden recorrer los índices junto con los elementos en un bucle con for index, item in enumerate(<str>).

>>> exercise = 'လေ့ကျင့်'

# Note that there are more code points than perceived glyphs or characters.
# Care should be used when iterating over languages that use
# combining characters, or when dealing with emoji.
>>> for code_point in exercise:
...    print(code_point)
...
လ
ေ
့
က
ျ
င
်
့

# Using enumerate will give both the value and index position of each element.
>>> for index, code_point in enumerate(exercise):
...    print(index, ": ", code_point)
...
0 :  လ
1 :  ေ
2 :  ့
3 :  က
4 :  ျ
5 :  င
6 :  ်
7 :  ့

Métodos de string

Python ofrece un amplio conjunto de métodos de string que te ayudan a buscar, limpiar, dividir, transformar, traducir y realizar muchas otras operaciones. Algunos de estos métodos se tratan en otro ejercicio.

Formato

Python también ofrece un amplio conjunto de herramientas para el formato y el uso de plantillas de strings, además de un procesamiento de texto más sofisticado mediante los módulos re (expresiones regulares), difflib (comparación de secuencias) y textwrap. Para una excelente introducción al formato de strings en Python, consulta esta entrada de Real Python. Para una introducción a los métodos de string, consulta Strings and Character Data in Python en el mismo sitio.

Tipos y codificaciones relacionados

Además de str (una secuencia de texto), Python tiene tipos de secuencia binaria correspondientes, resumidos en servicios de datos binarios: bytes (una secuencia binaria), bytearray y memoryview, para almacenar y manejar datos binarios de forma eficiente. Además, los Streams permiten enviar y recibir datos binarios por una conexión de red sin usar callbacks.