Video:cadenas de Python

¿Qué es una cadena en Python?

Una cadena es una secuencia de caracteres.

Un carácter es simplemente un símbolo. Por ejemplo, el idioma inglés tiene 26 caracteres.

Las computadoras no tratan con caracteres, tratan con números (binarios). Aunque es posible que vea caracteres en su pantalla, internamente se almacenan y manipulan como una combinación de 0 y 1.

Esta conversión de carácter a número se llama codificación y el proceso inverso es decodificación. ASCII y Unicode son algunas de las codificaciones populares utilizadas.

En Python, una cadena es una secuencia de caracteres Unicode. Unicode se introdujo para incluir todos los caracteres en todos los idiomas y brindar uniformidad en la codificación. Puede obtener información sobre Unicode en Python Unicode.

¿Cómo crear una cadena en Python?

Las cadenas se pueden crear encerrando caracteres dentro de comillas simples o dobles. Incluso las comillas triples se pueden usar en Python, pero generalmente se usan para representar cadenas de varias líneas y cadenas de documentación.

# defining strings in Python
# all of the following are equivalent
my_string = 'Hello'
print(my_string)

my_string = "Hello"
print(my_string)

my_string = '''Hello'''
print(my_string)

# triple quotes string can extend multiple lines
my_string = """Hello, welcome to
           the world of Python"""
print(my_string)

Cuando ejecute el programa, la salida será:

Hello
Hello
Hello
Hello, welcome to
           the world of Python

¿Cómo acceder a los caracteres de una cadena?

Podemos acceder a caracteres individuales mediante la indexación y a un rango de caracteres mediante el corte. El índice comienza desde 0. Intentar acceder a un carácter fuera del rango del índice generará un IndexError . El índice debe ser un número entero. No podemos usar flotantes u otros tipos, esto resultará en TypeError .

Python permite la indexación negativa de sus secuencias.

El índice de -1 se refiere al último elemento, -2 hasta el penúltimo elemento y así sucesivamente. Podemos acceder a un rango de elementos en una cadena usando el operador de corte : (dos puntos).

#Accessing string characters in Python
str = 'programiz'
print('str = ', str)

#first character
print('str[0] = ', str[0])

#last character
print('str[-1] = ', str[-1])

#slicing 2nd to 5th character
print('str[1:5] = ', str[1:5])

#slicing 6th to 2nd last character
print('str[5:-2] = ', str[5:-2])

Cuando ejecutamos el programa anterior, obtenemos el siguiente resultado:

str =  programiz
str[0] =  p
str[-1] =  z
str[1:5] =  rogr
str[5:-2] =  am

Si intentamos acceder a un índice fuera del rango o usamos números que no sean enteros, obtendremos errores.

# index must be in range
>>> my_string[15]  
...
IndexError: string index out of range

# index must be an integer
>>> my_string[1.5] 
...
TypeError: string indices must be integers

El corte se puede visualizar mejor considerando que el índice está entre los elementos, como se muestra a continuación.

Si queremos acceder a un rango, necesitamos el índice que dividirá la porción de la cadena.

¿Cómo cambiar o eliminar una cadena?

Las cadenas son inmutables. Esto significa que los elementos de una cadena no se pueden cambiar una vez que se han asignado. Simplemente podemos reasignar cadenas diferentes al mismo nombre.

>>> my_string = 'programiz'
>>> my_string[5] = 'a'
...
TypeError: 'str' object does not support item assignment
>>> my_string = 'Python'
>>> my_string
'Python'

No podemos eliminar o eliminar caracteres de una cadena. Pero es posible eliminar la cadena por completo usando del palabra clave.

>>> del my_string[1]
...
TypeError: 'str' object doesn't support item deletion
>>> del my_string
>>> my_string
...
NameError: name 'my_string' is not defined

Operaciones de cadenas de Python

Hay muchas operaciones que se pueden realizar con cadenas, lo que lo convierte en uno de los tipos de datos más utilizados en Python.

Para obtener más información sobre los tipos de datos disponibles en Python, visite:Tipos de datos de Python

Concatenación de dos o más cadenas

La unión de dos o más cadenas en una sola se denomina concatenación.

El + El operador hace esto en Python. Simplemente escribir dos cadenas literales juntas también las concatena.

El * El operador se puede utilizar para repetir la cadena un número determinado de veces.

# Python String Operations
str1 = 'Hello'
str2 ='World!'

# using +
print('str1 + str2 = ', str1 + str2)

# using *
print('str1 * 3 =', str1 * 3)

Cuando ejecutamos el programa anterior, obtenemos el siguiente resultado:

str1 + str2 =  HelloWorld!
str1 * 3 = HelloHelloHello

Escribir dos literales de cadena juntos también los concatena como + operador.

Si queremos concatenar cadenas en diferentes líneas, podemos usar paréntesis.

>>> # two string literals together
>>> 'Hello ''World!'
'Hello World!'

>>> # using parentheses
>>> s = ('Hello '
...      'World')
>>> s
'Hello World'

Iterando a través de una cadena

Podemos iterar a través de una cadena usando un bucle for. Aquí hay un ejemplo para contar el número de 'l' en una cadena.

# Iterating through a string
count = 0
for letter in 'Hello World':
    if(letter == 'l'):
        count += 1
print(count,'letters found')

Cuando ejecutamos el programa anterior, obtenemos el siguiente resultado:

3 letters found

Prueba de membresía de cadena

Podemos probar si existe una subcadena dentro de una cadena o no, usando la palabra clave in .

>>> 'a' in 'program'
True
>>> 'at' not in 'battle'
False

Funciones integradas para trabajar con Python

Varias funciones integradas que funcionan con secuencias también funcionan con cadenas.

Algunos de los más utilizados son enumerate() y len() . El enumerate() La función devuelve un objeto de enumeración. Contiene el índice y el valor de todos los elementos de la cadena como pares. Esto puede ser útil para la iteración.

Del mismo modo, len() devuelve la longitud (número de caracteres) de la cadena.

str = 'cold'

# enumerate()
list_enumerate = list(enumerate(str))
print('list(enumerate(str) = ', list_enumerate)

#character count
print('len(str) = ', len(str))

Cuando ejecutamos el programa anterior, obtenemos el siguiente resultado:

list(enumerate(str) =  [(0, 'c'), (1, 'o'), (2, 'l'), (3, 'd')]
len(str) =  4

Formato de cadenas de Python

Secuencia de escape

Si queremos imprimir un texto como Dijo, "¿Qué hay ahí?" , no podemos usar comillas simples ni comillas dobles. Esto resultará en un SyntaxError ya que el texto en sí contiene comillas simples y dobles.

>>> print("He said, "What's there?"")
...
SyntaxError: invalid syntax
>>> print('He said, "What's there?"')
...
SyntaxError: invalid syntax

Una forma de solucionar este problema es usar comillas triples. Alternativamente, podemos usar secuencias de escape.

Una secuencia de escape comienza con una barra invertida y se interpreta de manera diferente. Si usamos una comilla simple para representar una cadena, todas las comillas simples dentro de la cadena deben escaparse. Similar es el caso de las comillas dobles. Así es como se puede hacer para representar el texto anterior.

# using triple quotes
print('''He said, "What's there?"''')

# escaping single quotes
print('He said, "What\'s there?"')

# escaping double quotes
print("He said, \"What's there?\"")

Cuando ejecutamos el programa anterior, obtenemos el siguiente resultado:

He said, "What's there?"
He said, "What's there?"
He said, "What's there?"

Aquí hay una lista de todas las secuencias de escape admitidas por Python.

Aquí hay algunos ejemplos

>>> print("C:\\Python32\\Lib")
C:\Python32\Lib

>>> print("This is printed\nin two lines")
This is printed
in two lines

>>> print("This is \x48\x45\x58 representation")
This is HEX representation

Cadena sin procesar para ignorar la secuencia de escape

A veces podemos desear ignorar las secuencias de escape dentro de una cadena. Para ello podemos colocar r o R frente a la cuerda. Esto implicará que es una cadena sin procesar y cualquier secuencia de escape dentro de ella será ignorada.

>>> print("This is \x61 \ngood example")
This is a
good example
>>> print(r"This is \x61 \ngood example")
This is \x61 \ngood example

El método format() para formatear cadenas

El format() El método que está disponible con el objeto de cadena es muy versátil y poderoso para formatear cadenas. Las cadenas de formato contienen llaves {} como marcadores de posición o campos de reemplazo que se reemplazan.

Podemos usar argumentos posicionales o argumentos de palabras clave para especificar el orden.

# Python string format() method

# default(implicit) order
default_order = "{}, {} and {}".format('John','Bill','Sean')
print('\n--- Default Order ---')
print(default_order)

# order using positional argument
positional_order = "{1}, {0} and {2}".format('John','Bill','Sean')
print('\n--- Positional Order ---')
print(positional_order)

# order using keyword argument
keyword_order = "{s}, {b} and {j}".format(j='John',b='Bill',s='Sean')
print('\n--- Keyword Order ---')
print(keyword_order)

Cuando ejecutamos el programa anterior, obtenemos el siguiente resultado:

--- Default Order ---
John, Bill and Sean

--- Positional Order ---
Bill, John and Sean

--- Keyword Order ---
Sean, Bill and John

El format() El método puede tener especificaciones de formato opcionales. Se separan del nombre del campo mediante dos puntos. Por ejemplo, podemos justificar a la izquierda < , justifica a la derecha > o centro ^ una cadena en el espacio dado.

También podemos formatear números enteros como binarios, hexadecimales, etc. y los flotantes se pueden redondear o mostrar en formato de exponente. Hay toneladas de formato que puede usar. Visite aquí para ver todos los formatos de cadena disponibles con el format() método.

>>> # formatting integers
>>> "Binary representation of {0} is {0:b}".format(12)
'Binary representation of 12 is 1100'

>>> # formatting floats
>>> "Exponent representation: {0:e}".format(1566.345)
'Exponent representation: 1.566345e+03'

>>> # round off
>>> "One third is: {0:.3f}".format(1/3)
'One third is: 0.333'

>>> # string alignment
>>> "|{:<10}|{:^10}|{:>10}|".format('butter','bread','ham')
'|butter    |  bread   |       ham|'

Formato de estilo antiguo

Incluso podemos formatear cadenas como el antiguo sprintf() estilo utilizado en el lenguaje de programación C. Usamos el % operador para lograr esto.

>>> x = 12.3456789
>>> print('The value of x is %3.2f' %x)
The value of x is 12.35
>>> print('The value of x is %3.4f' %x)
The value of x is 12.3457

Métodos comunes de cadenas de Python

Hay numerosos métodos disponibles con el objeto de cadena. El format() El método que mencionamos anteriormente es uno de ellos. Algunos de los métodos comúnmente utilizados son lower() , upper() , join() , split() , find() , replace() etc. Aquí hay una lista completa de todos los métodos incorporados para trabajar con cadenas en Python.

>>> "PrOgRaMiZ".lower()
'programiz'
>>> "PrOgRaMiZ".upper()
'PROGRAMIZ'
>>> "This will split all words into a list".split()
['This', 'will', 'split', 'all', 'words', 'into', 'a', 'list']
>>> ' '.join(['This', 'will', 'join', 'all', 'words', 'into', 'a', 'string'])
'This will join all words into a string'
>>> 'Happy New Year'.find('ew')
7
>>> 'Happy New Year'.replace('Happy','Brilliant')
'Brilliant New Year'