Cada carácter de los strings tienen una posición en el índice:
También podemos utilizar el índice reverso, que también empieza por cero pero luego todos los números están al revés con el signo menor.
Utilizamos el método index( ) para explorar strings, ya que permite hallar el índice de aparición de un caracter o cadena de caracteres dentro de un texto dado. Sintaxis:
string.index(value, start, end)
- *string*: variable que almacena un string
- *value*: caracter(es) | buscado(s)
- *start*: las apariciones antes del índice start se ignoran
- *end*: las apariciones luego del índice end se ignoran
Búsqueda en sentido inverso. Sintaxis:
string.rindex(value, start, end)
Devuelve el caracter en el índice i*
string[i]
*: En Python, el índice en primera posición es el 0.
**count( ) **: retorna el número de veces que se repite un conjunto de caracteres especificado.
```python
"Hola mundo".count("Hola")
```
1
**find( ) e index( )** retornan la ubicación (comenzando desde el cero) en la que se encuentra el argumento indicado. Difieren en que index lanza ValueError cuando el argumento no es encontrado, mientras find retorna
```python
"Hola mundo".find("world")
```
-1
**rfind( ) y rindex( )**.Para buscar un conjunto de caracteres pero desde el final.
```python
"C:/python36/python.exe".rfind("/")
```
11
**startswith( ) y endswith( )** indican si la cadena en cuestión comienza o termina con el conjunto de caracteres pasados como argumento, y retornan True o False en función de ello.
```python
"Hola mundo".startswith("Hola")
```
True
**isdigit( )**: determina si todos los caracteres de la cadena son dígitos, o
pueden formar números, incluidos aquellos correspondientes a lenguas
orientales.
```python
"abc123".isdigit()
```
False
**isnumeric( )**: determina si todos los caracteres de la cadena son números, incluye también caracteres de connotación numérica que no necesariamente son dígitos (por ejemplo, una fracción).
```python
"1234".isnumeric()
```
True
**isdecimal( )**: determina si todos los caracteres de la cadena son decimales; esto es, formados por dígitos del 0 al 9.
```python
"1234".isdecimal()
```
True
**isalnum( )**: determina si todos los caracteres de la cadena son alfanuméricos.
```python
"abc123".isalnum()
```
True
**isalpha( )**: determina si todos los caracteres de la cadena son alfabéticos.
```python
"abc123".isalpha()
```
False
**islower()**: determina si todos los catacteres de la cadena son minúsculas.
```python
abcdef".islower()
```
True
**isupper()**: determina si todos los catacteres de la cadena son mayúsculas.
```python
"ABCDEF".isupper()
```
True
**isprintable( )**: determina si todos los caracteres de la cadena son imprimibles (es decir, no son caracteres especiales indicados por \...).
```python
"Hola \t mundo!".isprintable()
```
False
**isspace( )**: determina si todos los caracteres de la cadena son espacios.
```python
"Hola mundo".isspace()
```
False
### 3.3.2. - Métodos de transformación
En realidad los strings son inmutables; por ende, todos los métodos a continuación no actúan sobre el objeto original sino que retornan uno nuevo.
**capitalize( )** retorna la cadena con su primera letra en mayúscula.
```python
"hola mundo".capitalize()
```
'Hola mundo'
**encode( )** codifica la cadena con el mapa de caracteres especificado y retorna una instancia del tipo bytes.
```python
"Hola mundo".encode("utf-8")
```
b'Hola mundo'
**replace( )** reemplaza una cadena por otra.
```python
"Hola mundo".replace("mundo", "world")
```
'Hola world'
**lower( )** retorna una copia de la cadena con todas sus letras en minúsculas.
```python
"Hola Mundo!".lower()
```
'hola mundo!'
**upper( )** retorna una copia de la cadena con todas sus letras en mayúsculas.
```python
"Hola Mundo!".upper()
```
'HOLA MUNDO!'
**swapcase( )** cambia las mayúsculas por minúsculas y viceversa.
```python
"Hola Mundo!".swapcase()
```
'hOLA mUNDO!'
**strip( ), lstrip( ) y rstrip( )** remueven los espacios en blanco que preceden y/o suceden a la cadena.
```python
" Hola mundo! ".strip()
```
'Hola mundo!'
Los métodos **center( ), ljust( ) y rjust( )** alinean una cadena en el centro, la izquierda o la derecha. Un segundo argumento indica con qué caracter se deben llenar los espacios vacíos (por defecto un espacio en blanco).
```python
"Hola".center(10, "*")
```
'***Hola***'
### 3.3.3. - Métodos de separación y unión
**split( )** divide una cadena según un caracter separador (por defecto son espacios en blanco). Un segundo argumento en split( ) indica cuál es el máximo de divisiones que puede tener lugar (-1 por defecto para representar una cantidad ilimitada).
```python
"Hola mundo!\nHello world!".split()
```
['Hola', 'mundo!', 'Hello', 'world!']
**splitlines( )** divide una cadena con cada aparición de un salto de línea.
```python
"Hola mundo!\nHello world!".splitlines()
```
['Hola mundo!', 'Hello world!']
**partition( )** retorna una tupla de tres elementos: el bloque de caracteres anterior a la primera ocurrencia del separador, el separador mismo, y el bloque posterior.
```python
"Hola mundo. Hello world!".partition(" ")
```
('Hola', ' ', 'mundo. Hello world!')
**rpartition( )** opera del mismo modo que el anterior, pero partiendo de derecha a izquierda.
```python
"Hola mundo. Hello world!".rpartition(" ")
```
('Hola mundo. Hello', ' ', 'world!')
**join( )** debe ser llamado desde una cadena que actúa como separador para unir dentro de una misma cadena resultante los elementos de una lista.
Esto es lo que debes tener presente al trabajar con strings en Python:
- **Son inmutables**: una vez creados, no pueden modificarse sus partes, pero sí pueden reasignarse los valores de las variables a través de métodos de strings.
Las variables varian, pero los string son inmutables.
- **Concatenable**: es posible unir strings con el símbolo +
- **Multiplicable**: es posible concatenar repeticiones de un string con el símbolo *
- **Multilineales**: pueden escribirse en varias líneas al encerrarse entre triples comillas simples (''' ''') o dobles (""" """)
- **Determinar su longitud**: a través de la función len(mi_string)
- **Verificar su contenido**: a través de las palabras clave in y not in. El resultado de esta verificación es un booleano (True / False).
Los diccionarios son estructuras de datos que almacenan información en pares **clave:valor**. Son especialmente útiles para guardar y recuperar información a partir de los nombres de sus claves (no utilizan índices).
*: A partir de Python 3.7+, los diccionarios son tipos de datos ordenados, en el sentido que dicho orden se mantiene según su orden de inserción para aumentar la eficiencia en el uso de la memoria.
Los tuples o tuplas, son estructuras de datos que almacenan múltiples elementos en una única variable. Se caracterizan por ser ordenadas e inmutables. Esta característica las hace más eficientes en memoria y a prueba de daños, se procesan más rápido. Si se intentan cambiar devolverá un error.
> Mutable ❌ ordenado ✅ admite duplicados ✅
```python
mi_tuple = (1, "dos", [3.33, "cuatro"], (5.0, 6))
```
**indexado** (acceso a datos)
```python
print(mi_tuple[3][0])
```
5.0
**casting** (conversión de tipos de datos)
```python
lista_1 = list(mi_tuple)
print(lista_1)
```
[1, "dos", [3.33, "cuatro"], (5.0, 6)] # ahora es una estructura mutable
Los sets son otro tipo de estructuras de datos. Se diferenciande listas, tuplas y diccionarios porque son una colección mutable de elementos inmutables, no ordenados y sin datos repetidos.
> mutable ✅ ordenado ❌ admite duplicados ❌
```python
mi_set_a = {1, 2, "tres"}
mi_set_b = {3, "tres"}
```
### 3.8.1. - Métodos set
```python
mi_set_a = {1, 2, "tres"}
mi_set_b = {3, "tres"}
```
**add(item)** agrega un elemento al set
```python
mi_set_a.add(5)
print(mi_set_a)
```
{1, 2, "tres", 5}
**clear( )** remueve todos los elementos de un set
```python
mi_set_a.clear()
print(mi_set_a)
```
set()
**copy( )** retorna una copia del set
```python
mi_set_c = mi_set_a.copy()
print(mi_set_c)
```
{1, 2, "tres"}
**difference(set)** retorna el set formado por todos los elementos que únicamente existen en el set A
```python
mi_set_c = mi_set_a.difference(mi_set_b)
print(mi_set_c)
```
{1, 2}
**difference_update(set)** remueve de A todos los elementos comunes a AyB
```python
mi_set_a.difference_update(mi_set_b)
print(mi_set_a)
```
{1, 2}
**discard(item)** remueve un elemento del set
```python
mi_set_a.discard("tres")
print(mi_set_a)
```
{1, 2}
**intersection(set)** retorna el set formado por todos los elementos que existen en A y B simultáneamente.
```python
mi_set_c = mi_set_a.intersection(mi_set_b)
print(mi_set_c)
```
{'tres'}
**intersection_update(set)** mantiene únicamente los elementos comunes a A y B
```python
mi_set_b.intersection_update(mi_set_a)
print(mi_set_b)
```
{"tres"}
**isdisjoint(set)** devuelve True si A y B no tienen elementos en común
```python
conjunto_disjunto = mi_set_a.isdisjoint(mi_set_b)
print(conjunto_disjunto)
```
False
**issubset(set)** devuelve True si todos los elementos de B están presentes en A
```python
es_subset = mi_set_b.issubset(mi_set_a)
print(es_subset)
```
False
**issuperset(set)** devuelve True si A contiene todos los elementos de B
```python
es_superset = mi_set_a.issuperset(mi_set_b)
print(es_superset)
```
False
**pop( )** elimina y retorna un elemento al azar del set
```python
aleatorio = mi_set_a.pop()
print(aleatorio)
```
{2}
**remove(item)** elimina un item del set, y arroja error si no existe
```python
mi_set_a.remove("tres")
print(mi_set_a)
```
{1, 2}
**symmetric_difference(set)** retorna todos los elementos de A y B, excepto aquellos que son comunes a los dos
La consigna es la siguiente: vas a crear un programa que primero le pida al usuario que ingrese un texto. Puede ser un texto cualquiera: un artículo entero, un párrafo, una frase, un poema, lo que quiera.
Luego, el programa le va a pedir al usuario que también ingrese tres letras a su elección y a partir de ese momento nuestro código va a procesar esa información para hacer cinco tipos de análisis y devolverle al usuario la siguiente información:
1. Primero: ¿cuántas veces aparece cada una de las letras que eligió? Para lograr esto, te recomiendo almacenar esas letras en una lista y luego usar algún método propio de string que nos permita contar cuantas veces aparece un sub string dentro del string. Algo que debes tener en cuenta es que al buscar las letras pueden haber mayúsculas y minúsculas y esto va a afectar el resultado. Lo que deberías hacer para asegurarte de que se encuentren absolutamente todas las letras es pasar, tanto el texto original como las letras a buscar, a minúsculas.
2. Segundo: le vas a decir al usuario cuántas palabras hay a lo largo de todo el texto. Y para lograr esta parte, recuerda que hay un método de string que permite transformarlo en una lista y que luego hay una función que permite averiguar el largo de una lista.
3. Tercero: nos va a informar cuál es la primera letra del texto y cuál es la última. Aquí claramente echaremos mano de la indexación.
4. Cuarto: el sistema nos va a mostrar cómo quedaría el texto si invirtiéramos el orden de las palabras. ¿Acaso hay algún método que permita invertir el orden de una lista, y otro que permita unir esos elementos con espacios intermedios? Piénsalo.
5. Y por último: el sistema nos va a decir si la palabra “Python” se encuentra dentro del texto. Esta parte puede ser algo complicada de imaginársela, pero te voy a dar una pista: puedes usar booleanos para hacer tu averiguación y un diccionario para encontrar la manera de expresarle al usuario tu respuesta.
