3.1.2. Cadenas de caracteres
Además de números, Python puede manipular cadenas de texto, las
cuales pueden ser expresadas de distintas formas. Pueden estar
encerradas en comillas simples ('...') o dobles ("...") con el mismo resultado 2. \ puede ser usado para escapar comillas:
>>> 'spam eggs' # single quotes
'spam eggs'
>>> 'doesn\'t' # use \' to escape the single quote...
"doesn't"
>>> "doesn't" # ...or use double quotes instead
"doesn't"
>>> '"Yes," they said.'
'"Yes," they said.'
>>> "\"Yes,\" they said."
'"Yes," they said.'
>>> '"Isn\'t," they said.'
'"Isn\'t," they said.'
En el intérprete interactivo, la salida de caracteres está encerrada
en comillas y los caracteres especiales se escapan con barras
invertidas. Aunque esto a veces se vea diferente de la entrada (las
comillas que encierran pueden cambiar), las dos cadenas son
equivalentes. La cadena se encierra en comillas dobles si la cadena
contiene una comilla simple y ninguna doble, de lo contrario es
encerrada en comillas simples. La función print() produce una salida más legible, omitiendo las comillas que la encierran e imprimiendo caracteres especiales y escapados:
>>> '"Isn\'t," they said.'
'"Isn\'t," they said.'
>>> print('"Isn\'t," they said.')
"Isn't," they said.
>>> s = 'First line.\nSecond line.' # \n means newline
>>> s # without print(), \n is included in the output
'First line.\nSecond line.'
>>> print(s) # with print(), \n produces a new line
First line.
Second line.
Si no quieres que los caracteres precedidos por \ se interpreten como caracteres especiales, puedes usar cadenas sin formato agregando una r antes de la primera comilla:
>>> print('C:\some\name') # here \n means newline!
C:\some
ame
>>> print(r'C:\some\name') # note the r before the quote
C:\some\name
Las cadenas de texto literales pueden contener múltiples líneas. Una forma es usar triples comillas: """...""" o '''...'''. Los fin de línea son incluidos automáticamente, pero es posible prevenir esto agregando una \ al final de la línea. Por ejemplo:
print("""\
Usage: thingy [OPTIONS]
-h Display this usage message
-H hostname Hostname to connect to
""")
produce la siguiente salida (tened en cuenta que la línea inicial no está incluida):
Usage: thingy [OPTIONS]
-h Display this usage message
-H hostname Hostname to connect to
Las cadenas se pueden concatenar (pegar juntas) con el operador + y se pueden repetir con *:
>>> # 3 times 'un', followed by 'ium'
>>> 3 * 'un' + 'ium'
'unununium'
Dos o más cadenas literales (es decir, las encerradas entre comillas) una al lado de la otra se concatenan automáticamente.
>>> 'Py' 'thon'
'Python'
Esta característica es particularmente útil cuando quieres dividir cadenas largas:
>>> text = ('Put several strings within parentheses '
... 'to have them joined together.')
>>> text
'Put several strings within parentheses to have them joined together.'
Esto solo funciona con dos literales, no con variables ni expresiones:
>>> prefix = 'Py'
>>> prefix 'thon' # can't concatenate a variable and a string literal
File "<stdin>", line 1
prefix 'thon'
^
SyntaxError: invalid syntax
>>> ('un' * 3) 'ium'
File "<stdin>", line 1
('un' * 3) 'ium'
^
SyntaxError: invalid syntax
Si quieres concatenar variables o una variable y un literal, usa +:
>>> prefix + 'thon'
'Python'
Las cadenas de texto se pueden indexar (subíndices), el primer carácter de la cadena tiene el índice 0. No hay un tipo de dato diferente para los caracteres; un carácter es simplemente una cadena de longitud uno:
>>> word = 'Python'
>>> word[0] # character in position 0
'P'
>>> word[5] # character in position 5
'n'
Los índices quizás sean números negativos, para empezar a contar desde la derecha:
>>> word[-1] # last character
'n'
>>> word[-2] # second-last character
'o'
>>> word[-6]
'P'
Nota que -0 es lo mismo que 0, los índice negativos comienzan desde -1.
Además de los índices, las rebanadas también están soportadas. Mientras que los índices se utilizar para obtener caracteres individuales, las rebanadas te permiten obtener partes de las cadenas de texto:
>>> word[0:2] # characters from position 0 (included) to 2 (excluded)
'Py'
>>> word[2:5] # characters from position 2 (included) to 5 (excluded)
'tho'
Los índices de las rebanadas tienen valores por defecto útiles; el valor por defecto para el primer índice es cero, el valor por defecto para el segundo índice es la longitud de la cadena a rebanar.
>>> word[:2] # character from the beginning to position 2 (excluded)
'Py'
>>> word[4:] # characters from position 4 (included) to the end
'on'
>>> word[-2:] # characters from the second-last (included) to the end
'on'
Nota cómo el inicio siempre se incluye y el final siempre se excluye. Esto asegura que s[:i] + s[i:] siempre sea igual a s:
>>> word[:2] + word[2:]
'Python'
>>> word[:4] + word[4:]
'Python'
Una forma de recordar cómo funcionan las rebanadas es pensar que los índices apuntan entre caracteres, con el borde izquierdo del primer carácter numerado 0. Luego, el punto derecho del último carácter de una cadena de n caracteres tiene un índice n, por ejemplo
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5 6
-6 -5 -4 -3 -2 -1
La primera fila de números da la posición de los índices 0…6 en la cadena; La segunda fila da los correspondientes indices negativos. La rebanada desde i hasta j consta de todos los caracteres entre los bordes etiquetados i y j, respectivamente.
Para índices no negativos, la longitud de la rebanada es la
diferencia de los índices, si ambos están dentro de los límites. Por
ejemplo, la longitud de word[1:3] es 2.
Intentar usar un índice que es muy grande resultará en un error:
>>> word[42] # the word only has 6 characters
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: string index out of range
Sin embargo, los índices de rebanadas fuera de rango se manejan satisfactoriamente cuando se usan para rebanar:
>>> word[4:42]
'on'
>>> word[42:]
''
Las cadenas de Python no se pueden modificar, son immutable. Por eso, asignar a una posición indexada de la cadena resulta en un error:
>>> word[0] = 'J'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>> word[2:] = 'py'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
Si necesitas una cadena diferente, deberías crear una nueva:
>>> 'J' + word[1:]
'Jython'
>>> word[:2] + 'py'
'Pypy'
La función incorporada len() retorna la longitud de una cadena:
>>> s = 'supercalifragilisticexpialidocious'
>>> len(s)
34
