You've already forked Curso-lenguaje-python
Restructure content and add notes from HolaMundo
Signed-off-by: Manuel Vergara <manuel@vergaracarmona.es>
This commit is contained in:
24
python-total/dia_03/01_index.py
Normal file
24
python-total/dia_03/01_index.py
Normal file
@@ -0,0 +1,24 @@
|
||||
|
||||
print("# BUSCAR LA POSICIÓN DE UN CARACTER")
|
||||
# CON index() PODEMOS ENCONTRAR LA POSICIÓN DE UN CARACTER EN UN STRING
|
||||
mi_texto = "hola mundo"
|
||||
posicion = mi_texto.index("o",0,11)
|
||||
print(f"EJEMPLO: La posición del caracter \"o\" es {posicion}")
|
||||
|
||||
# PREGUNTAR LETRA Y DAR POSICIÓN EN FRASE
|
||||
pregunta_carater = input("PREGUNTA: De qué carater quieres saber la posición: ")
|
||||
print(f"El carater \"{pregunta_carater}\" está en la posición \"{mi_texto.index(pregunta_carater)}\"")
|
||||
|
||||
print("\n# SE PUEDE BUSCAR CON rindex PARA BUSCAR DE DERECHA A IZQUIERDA")
|
||||
posicion_r = mi_texto.rindex("o")
|
||||
print(f"EJEMPLO: La posición en búsqueda reversa del caracter \"o\" es {posicion_r}")
|
||||
|
||||
print("\n# BUSCAR EL CARACTER DE UNA POSICIÓN")
|
||||
# SABER LA LETRA DE UNA POSICIÓN
|
||||
que_carater = mi_texto[3]
|
||||
print(f"EJEMPLO: El carater en la posición \"3\" del string es la \"{que_carater}\"")
|
||||
|
||||
# PREGUNTAR POSICIÓN Y DAR RESULTADO EN FRASE
|
||||
pregunta_posicion = int(input("PREGUNTA: De que posición quieres saber el caracter: "))
|
||||
resultado_posicion = mi_texto[pregunta_posicion]
|
||||
print(f"En la posición \"{pregunta_posicion}\" está el caracter \"{resultado_posicion}\"")
|
||||
32
python-total/dia_03/02_sub_strings.py
Normal file
32
python-total/dia_03/02_sub_strings.py
Normal file
@@ -0,0 +1,32 @@
|
||||
# DISTINTAS POSIBILIDADES CON Sub-strings. slicing (rebanar)
|
||||
|
||||
# Limitando la rebanada
|
||||
print("# Limitando la rebanada")
|
||||
texto = "ABCDEFGHIJKLMNÑOPQRSTUVWXYZ"
|
||||
fragmento01 = texto[2:15]
|
||||
print(fragmento01)
|
||||
|
||||
# Hasta el final
|
||||
print("# Hasta el final")
|
||||
fragmento02 = texto[2:]
|
||||
print(fragmento02)
|
||||
|
||||
# Desde el inicio
|
||||
print("# Desde el inicio")
|
||||
fragmento03 = texto[:10]
|
||||
print(fragmento03)
|
||||
|
||||
# Con saltos de dos
|
||||
print("# Con saltos de dos")
|
||||
fragmento04 = texto[2:15:2]
|
||||
print(fragmento04)
|
||||
|
||||
# Con saltos de tres de prinicipio a fin
|
||||
print("# Con saltos de tres de prinicipio a fin")
|
||||
fragmento05 = texto[::3]
|
||||
print(fragmento05)
|
||||
|
||||
# Con saltos de dos desde el final
|
||||
print("# Con saltos de dos desde el final")
|
||||
fragmento06 = texto[::-2]
|
||||
print(fragmento06)
|
||||
53
python-total/dia_03/03_metodos.py
Normal file
53
python-total/dia_03/03_metodos.py
Normal file
@@ -0,0 +1,53 @@
|
||||
""" Métodos en strings """
|
||||
|
||||
texto = "Este es el texto de Federico"
|
||||
|
||||
# Mayúsculas
|
||||
resultado01 = texto.upper()
|
||||
print(resultado01)
|
||||
|
||||
# Mayúsculas (Podemos determinar un índice)
|
||||
resultado02 = texto[20].upper()
|
||||
print(resultado02)
|
||||
|
||||
# Mayúsculas
|
||||
resultado03 = texto.upper()
|
||||
print(resultado03)
|
||||
|
||||
# Split (Separar dentro de una lista)
|
||||
resultado04 = texto.split()
|
||||
print(resultado04)
|
||||
|
||||
# Split (Separar dentro de una lista) Se puede seleccionar el elemento separador
|
||||
resultado05 = texto.split(" ")
|
||||
print(resultado05)
|
||||
|
||||
# Join
|
||||
a = "Aprender"
|
||||
b = "Python"
|
||||
c = "es"
|
||||
d = "genial"
|
||||
unir = "-".join([a,b,c,d])
|
||||
print(unir)
|
||||
|
||||
# Find
|
||||
resultado06 = texto.find("F")
|
||||
print(resultado06)
|
||||
|
||||
## La diferencia de find con index es que
|
||||
## si buscas un carácter que no existe no da error
|
||||
## arroja el valor -1
|
||||
resultado07 = texto.find("g")
|
||||
print(resultado07)
|
||||
|
||||
# Reemplazar
|
||||
resultado08 = texto.replace("Federico", "Manuel")
|
||||
print(resultado08)
|
||||
|
||||
|
||||
frase = "Si la implementación es difícil de explicar, puede que sea una mala idea."
|
||||
|
||||
resultado001 = frase.replace("difícil","fácil")
|
||||
resultado002 = resultado001.replace("mala","buena")
|
||||
|
||||
print(resultado002)
|
||||
55
python-total/dia_03/04_string.py
Normal file
55
python-total/dia_03/04_string.py
Normal file
@@ -0,0 +1,55 @@
|
||||
# Métodos de strings
|
||||
|
||||
## Métodos de análisis
|
||||
|
||||
print("Hola mundo".count("Hola"))
|
||||
|
||||
print("Hola mundo".find("world"))
|
||||
|
||||
print("C:/python36/python.exe".rfind("/"))
|
||||
|
||||
print("Hola mundo".startswith("Hola"))
|
||||
|
||||
print("abc123".isdigit())
|
||||
|
||||
print("1234".isnumeric())
|
||||
|
||||
print("1234".isdecimal())
|
||||
|
||||
print("abc123".isalnum())
|
||||
|
||||
print("abc123".isalpha())
|
||||
|
||||
print("abcdef".islower())
|
||||
|
||||
print("ABCDEF".isupper())
|
||||
|
||||
print("Hola mundo".isspace())
|
||||
|
||||
print("hola mundo".capitalize())
|
||||
|
||||
print("Hola mundo".encode("utf-8"))
|
||||
|
||||
print("Hola mundo".replace("mundo", "world"))
|
||||
|
||||
print("Hola Mundo!".lower())
|
||||
|
||||
print("Hola Mundo!".upper())
|
||||
|
||||
print("Hola Mundo!".swapcase())
|
||||
|
||||
print(" Hola mundo! ".strip())
|
||||
|
||||
print("Hola".center(10, "*"))
|
||||
|
||||
print("Hola mundo!\nHello world!".split())
|
||||
|
||||
print("Hola mundo!\nHello world!".splitlines())
|
||||
|
||||
print("Hola mundo. Hello world!".partition(" "))
|
||||
|
||||
print("Hola mundo. Hello world!".rpartition(" "))
|
||||
|
||||
print(", ".join(["C", "C++", "Python", "Java"]))
|
||||
|
||||
|
||||
37
python-total/dia_03/05_propiedades.py
Normal file
37
python-total/dia_03/05_propiedades.py
Normal file
@@ -0,0 +1,37 @@
|
||||
#INMUTABLE
|
||||
# Este código intenta cambiar un caracter del string,
|
||||
# con lo que no permitirá, dará error
|
||||
|
||||
# nombre = "Carina"
|
||||
# nombre[0] = "K"
|
||||
# print(nombre)
|
||||
|
||||
#CONCATENAR
|
||||
n1 = "Kari"
|
||||
n2 = "na"
|
||||
print(n1 + n2)
|
||||
|
||||
# MULTIPLICAR
|
||||
print(n1 * 5)
|
||||
|
||||
# MULTILINEA
|
||||
# Perfecto para poemas
|
||||
poema = """ Mil pequeños peces blancos
|
||||
como si hirviera
|
||||
el color del agua."""
|
||||
print(poema)
|
||||
|
||||
# VERIFICAR contenido. booleano
|
||||
print("agua" in poema)
|
||||
|
||||
# También se puede verificar si NO está
|
||||
print("escorbuto" not in poema)
|
||||
|
||||
# LONGITUD DE STRING
|
||||
print(len(poema))
|
||||
|
||||
print(len("Otro ejemplo"))
|
||||
print(len("Anticonstitucionalidades"))
|
||||
print(len("electroencefalografistas"))
|
||||
print(len("Esternocleidomastoideo"))
|
||||
|
||||
36
python-total/dia_03/06_listas.py
Normal file
36
python-total/dia_03/06_listas.py
Normal file
@@ -0,0 +1,36 @@
|
||||
# LAS LISTAS
|
||||
lista_1 = ["C", "C++", "Python", "Java"]
|
||||
lista_2 = ["PHP", "SQL", "Visual Basic"]
|
||||
lista_3 = ["d", "a", "c", "b", "e"]
|
||||
lista_4 = [5, 4, 7, 1, 9]
|
||||
|
||||
# Ver tipo de dato de las listas
|
||||
print(type(lista_1))
|
||||
|
||||
# Concatenar listas
|
||||
lista_1_2 = lista_1 + lista_2
|
||||
print(lista_1_2)
|
||||
|
||||
# EN LAS LISTAS SE PUEDEN MODIFICAR LOS ELEMENTOS
|
||||
# Agregar un elemento a la lista
|
||||
lista_1.append("R")
|
||||
print(lista_1)
|
||||
|
||||
# Eliminar un elemento de la lista con el índice (Devuelve el valor eliminado)
|
||||
print(lista_1.pop(4))
|
||||
|
||||
guardar_elemento = lista_1_2.pop(2)
|
||||
print(guardar_elemento)
|
||||
|
||||
# Ordenar los elementos de la lista
|
||||
lista_3.sort()
|
||||
print(lista_3)
|
||||
# Cuidado que no devuelve nada, modifica la variable
|
||||
guardar_sort = lista_3.sort()
|
||||
print(guardar_sort)
|
||||
# Es de tipo None, un objecto sin valor, que no es lo mismo que 0
|
||||
print(type(guardar_sort))
|
||||
|
||||
# Invierte el orden de los elementos (No es lo opuesto a sort)
|
||||
lista_4.reverse()
|
||||
print(lista_4)
|
||||
56
python-total/dia_03/07_diccionarios.py
Normal file
56
python-total/dia_03/07_diccionarios.py
Normal file
@@ -0,0 +1,56 @@
|
||||
# DICCIONARIOS (No se puede repetir el valor)
|
||||
mi_diccionario = {"c1":"valor1","c2":"valor2"}
|
||||
print(type(mi_diccionario))
|
||||
print(mi_diccionario)
|
||||
|
||||
# Guardando un valor
|
||||
resultado = mi_diccionario['c1']
|
||||
print(resultado)
|
||||
|
||||
# Ejemplo 1
|
||||
cliente = {
|
||||
'nombre':'Juan',
|
||||
'apellido':'Fuentes',
|
||||
'peso':'88',
|
||||
'talla':'1760'
|
||||
}
|
||||
consulta = (cliente['talla'])
|
||||
print(consulta)
|
||||
|
||||
# Ejemplo 2
|
||||
paciente ={
|
||||
"nombre":"Eusebio",
|
||||
"apellido":"García",
|
||||
"peso":82.6,
|
||||
"altura":"172"
|
||||
}
|
||||
print(f"El paciente se llama {paciente['nombre']} {paciente['apellido']} pesa {paciente['peso']} kg y mide {paciente['altura']} cm.")
|
||||
|
||||
# Diccionarios anidados y listas anidadas
|
||||
dic = {'c1':55,'c2':[10,20,30],'c3':{'s1':100,'s2':200}}
|
||||
print(dic['c2'])
|
||||
print(dic['c2'][1])
|
||||
print(dic['c3'])
|
||||
print(dic['c3']['s2'])
|
||||
|
||||
# Ejercicio sacar la letra e en mayúscula
|
||||
diccio = {'c1':['a','b','c'],'c2':['d','e','f']}
|
||||
print(diccio['c2'][1].upper())
|
||||
|
||||
# Cambios en un diccionario
|
||||
dic2 = {1:'a',2:'b'}
|
||||
print(dic2)
|
||||
dic2[3] = 'c'
|
||||
print(dic2)
|
||||
dic2[2] = 'B'
|
||||
print(dic2)
|
||||
print(dic2.keys())
|
||||
print(dic2.values())
|
||||
print(dic2.items())
|
||||
|
||||
mi_dic = {"nombre":"Karen", "apellido":"Jurgens", "edad":35, "ocupacion":"Periodista"}
|
||||
mi_dic['edad'] = 36
|
||||
mi_dic['ocupacion'] = 'Editora'
|
||||
mi_dic['pais'] = 'Colombia'
|
||||
|
||||
print(mi_dic)
|
||||
33
python-total/dia_03/08_tuplas.py
Normal file
33
python-total/dia_03/08_tuplas.py
Normal file
@@ -0,0 +1,33 @@
|
||||
mi_tuple = (1,2,3,4)
|
||||
mi_tuple2 = 1,2,(10,20),4
|
||||
print(type(mi_tuple))
|
||||
print(mi_tuple2)
|
||||
|
||||
print(mi_tuple[2])
|
||||
print(mi_tuple[-2])
|
||||
|
||||
print(mi_tuple2[2][0])
|
||||
|
||||
# El tuple se puede convertir en una lista
|
||||
mi_tuple =list(mi_tuple)
|
||||
print(type(mi_tuple))
|
||||
# También al revés, se puede convertir una lista en un tuple
|
||||
mi_tuple =tuple(mi_tuple)
|
||||
print(type(mi_tuple))
|
||||
|
||||
# Se puede dar cada uno de los valores a una variable distinta
|
||||
# pero tienen que coincidir la cantidad de valores con las variables
|
||||
t = 1,2,1
|
||||
x,y,z = t
|
||||
print(x, y, z)
|
||||
|
||||
# Se puede pedir el número de elementos
|
||||
print(len(t))
|
||||
|
||||
# Se puede contar la cantidad de apareciones de un valor
|
||||
print(t.count(1))
|
||||
|
||||
# También se puede consultar el indice de un valor
|
||||
print(t.index(2))
|
||||
|
||||
|
||||
46
python-total/dia_03/09_set.py
Normal file
46
python-total/dia_03/09_set.py
Normal file
@@ -0,0 +1,46 @@
|
||||
""" Sets """
|
||||
|
||||
mi_set = set([1, 2, 3, 4, 5])
|
||||
print(type(mi_set))
|
||||
print(mi_set)
|
||||
|
||||
# No acepta repeticiones
|
||||
# No acepta listas
|
||||
# pero sí tuples porque son inmutables
|
||||
otro_set = set([1, 2, 3, 4, 5, (1,2,3), 1, 1, 1])
|
||||
print(otro_set)
|
||||
|
||||
print(len(mi_set))
|
||||
|
||||
print(2 in mi_set)
|
||||
|
||||
# MÉTODOS
|
||||
|
||||
# Union
|
||||
s1 = {1,2,3}
|
||||
s2 = {3,4,5}
|
||||
s3 = s1.union(s2)
|
||||
print(s3)
|
||||
|
||||
# Agregar
|
||||
s1.add(4)
|
||||
print(s1)
|
||||
|
||||
# Eliminar. Si no encuentra el elemento
|
||||
# da error
|
||||
s1.remove(3)
|
||||
print(s1)
|
||||
|
||||
# Descartar. Funciona como remove
|
||||
# pero no da error si no encuentra el elemento
|
||||
s1.discard(3)
|
||||
print(s1)
|
||||
|
||||
# Elimina un elemento aleatorio
|
||||
sorteo = s1.pop()
|
||||
print(sorteo)
|
||||
print(s1)
|
||||
|
||||
# Vaciar el set
|
||||
s1.clear()
|
||||
print(s1)
|
||||
23
python-total/dia_03/10_booleanos.py
Normal file
23
python-total/dia_03/10_booleanos.py
Normal file
@@ -0,0 +1,23 @@
|
||||
"""
|
||||
booleano
|
||||
"""
|
||||
|
||||
# Creación directa del booleano
|
||||
var1 = True
|
||||
var2 = False
|
||||
print(type(var1))
|
||||
print(var1)
|
||||
|
||||
# Creación indirecta del booleano
|
||||
numero = 5 > 2+3
|
||||
print(type(numero))
|
||||
print(numero)
|
||||
|
||||
# Creación explícita
|
||||
compara = bool(5 != 5+1)
|
||||
print(compara)
|
||||
|
||||
lista = (1, 2, 3, 4)
|
||||
control = 5 not in lista
|
||||
print(type(control))
|
||||
print(control)
|
||||
31
python-total/dia_03/11_programa03.py
Normal file
31
python-total/dia_03/11_programa03.py
Normal file
@@ -0,0 +1,31 @@
|
||||
"""
|
||||
Programa día 3 - Analizador de text
|
||||
"""
|
||||
|
||||
txt = input("""
|
||||
Ingresa un texto para analizar
|
||||
""")
|
||||
|
||||
print("\nIngresa tres letras por favor")
|
||||
l1 = input("\tIngresa la primera letra: ")
|
||||
l2 = input("\tIngresa la segunda letra: ")
|
||||
l3 = input("\tIngresa la tercera letra: ")
|
||||
|
||||
letras = [l1, l2, l3]
|
||||
|
||||
print("\nPRIMERO. Vamos a ver las veces que aparecen las letras en el texto:")
|
||||
print(f"\t- La letra {l1} se encuentra {txt.lower().count(letras[0].lower())} veces en el texto.")
|
||||
print(f"\t- La letra {l2} se encuentra {txt.lower().count(letras[1].lower())} veces en el texto.")
|
||||
print(f"\t- La letra {l3} se encuentra {txt.lower().count(letras[2].lower())} veces en el texto.")
|
||||
|
||||
print(f"\nSEGUNDO. El texto tiene {len(txt.split())} palabras.")
|
||||
|
||||
pos_pri = txt[0]
|
||||
pos_fin = txt[-1]
|
||||
print(f"\nTERCERO. La primera letra del texto es \"{pos_pri}\" y la última es \"{pos_fin}\"")
|
||||
|
||||
print(f"\nCUARTO. Cuidao, el texto al revés es así:\n{' '.join(txt[::-1])}")
|
||||
|
||||
ser_o_no_ser = ("python" in txt)
|
||||
dic_si_o_no = {True:"sí",False:"no"}
|
||||
print(f"\nQUINTO. La palabra python {dic_si_o_no[ser_o_no_ser]} se encuentra en el texto")
|
||||
646
python-total/dia_03/README.md
Normal file
646
python-total/dia_03/README.md
Normal file
@@ -0,0 +1,646 @@
|
||||
# Día 3 - Programa un analizador de texto
|
||||
Los strings en python tienen incorporados más de 30 métodos que nos permiten manipularlos y analizarlos. Aquí veremos algunos de los más importantes.
|
||||
|
||||
## Índice
|
||||
- [Día 3 - Programa un analizador de texto](#día-3---programa-un-analizador-de-texto)
|
||||
- [Índice](#índice)
|
||||
- [3.1. - Index( )](#31---index-)
|
||||
- [3.2. - Substrings](#32---substrings)
|
||||
- [3.3. - Métodos para Strings](#33---métodos-para-strings)
|
||||
- [3.3.1. - Métodos de análisis](#331---métodos-de-análisis)
|
||||
- [3.3.2. - Métodos de transformación](#332---métodos-de-transformación)
|
||||
- [3.3.3. - Métodos de separación y unión](#333---métodos-de-separación-y-unión)
|
||||
- [3.4. - Strings: propiedades](#34---strings-propiedades)
|
||||
- [3.5. - Listas](#35---listas)
|
||||
- [3.6. - Diccionarios](#36---diccionarios)
|
||||
- [3.7. - Tuples](#37---tuples)
|
||||
- [3.8. - sets](#38---sets)
|
||||
- [3.8.1. - Métodos set](#381---métodos-set)
|
||||
- [3.9. - booleanos](#39---booleanos)
|
||||
- [3.9.1. - operadores lógicos](#391---operadores-lógicos)
|
||||
- [3.10. - Proyecto del Día 3](#310---proyecto-del-día-3)
|
||||
- [Ficheros y documentación del día 3](#ficheros-y-documentación-del-día-3)
|
||||
|
||||
## 3.1. - Index( )
|
||||
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.
|
||||
|
||||
## 3.2. - Substrings
|
||||
|
||||
Podemos extraer porciones de texto utilizando las herramientas de manipulación de strings conocidas como slicing (rebanar). Sintaxis:
|
||||
|
||||
string[start:stop:step]
|
||||
|
||||
- *start*: índice de inicio del sub-string (incluido)
|
||||
- *stop*: índice del final del sub-string (no incluido)
|
||||
- *step*: paso
|
||||
|
||||
Ejemplos:
|
||||
|
||||
|
||||
|
||||
```python
|
||||
saludo = H o l a _ M u n d o
|
||||
print(saludo[2:6])
|
||||
```
|
||||
la_M
|
||||
|
||||
|
||||
|
||||
|
||||
```python
|
||||
print(saludo[3::3])
|
||||
```
|
||||
auo
|
||||
|
||||
|
||||
|
||||
```python
|
||||
print(saludo[::-1])
|
||||
```
|
||||
|
||||
odnuM_aloH
|
||||
|
||||
## 3.3. - Métodos para Strings
|
||||
|
||||
### 3.3.1. - Métodos de análisis
|
||||
**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.
|
||||
```python
|
||||
", ".join(["C", "C++", "Python", "Java"])
|
||||
```
|
||||
|
||||
'C, C++, Python, Java
|
||||
|
||||
|
||||
## 3.4. - Strings: propiedades
|
||||
|
||||
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).
|
||||
|
||||
|
||||
|
||||
## 3.5. - Listas
|
||||
|
||||
Se pueden anidar listas. Se puede analizar y manipularlas, son mutables.
|
||||
|
||||
Una lista es de tipo `<class 'list'>`. Se pueden añadir tanto elementos str, int... todos juntos sin conflictos.
|
||||
|
||||
Igual que los strings, se puede seleccionar los elementos por su índice como un array:
|
||||
```python
|
||||
mi_lista[0:]
|
||||
```
|
||||
|
||||
Se pueden concatenar las listas.
|
||||
```python
|
||||
lista_1 = ["C", "C++", "Python", "Java"]
|
||||
lista_2 = ["PHP", "SQL", "Visual Basic"]
|
||||
lista_3 = ["d", "a", "c", "b", "e"]
|
||||
lista_4 = [5, 4, 7, 1, 9]
|
||||
```
|
||||
|
||||
**función append( )**: agrega un elemento a una lista en el lugar
|
||||
```python
|
||||
lista_1.append("R")
|
||||
print(lista_1)
|
||||
```
|
||||
|
||||
["C", "C++", "Python", "Java", "R"]
|
||||
|
||||
**función pop( )**: elimina un elemento de la lista dado el índice, y devuelve el valor quitado
|
||||
```python
|
||||
print(lista_1.pop(4))
|
||||
```
|
||||
|
||||
"R"
|
||||
|
||||
**función sort( )**: ordena los elementos de la lista en el lugar
|
||||
```python
|
||||
lista_3.sort()
|
||||
print(lista_3)
|
||||
```
|
||||
|
||||
['a', 'b', 'c', 'd', 'e']
|
||||
|
||||
**función reverse( )**: invierte el orden de los elementos en el lugar. *
|
||||
```python
|
||||
lista_4.reverse()
|
||||
print(lista_4)
|
||||
```
|
||||
|
||||
[9, 1, 7, 4, 5]
|
||||
|
||||
## 3.6. - Diccionarios
|
||||
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).
|
||||
|
||||
> mutable ✅ ordenado ❌* admite duplicados❌:✅
|
||||
|
||||
```python
|
||||
mi_diccionario = {"curso":"Python TOTAL","clase":"Diccionarios"}
|
||||
```
|
||||
|
||||
Agregar nuevos datos, o modificarlos:
|
||||
```python
|
||||
mi_diccionario["recursos"] = ["notas","ejercicios"]
|
||||
```
|
||||
|
||||
Acceso a valores a través del nombre de las claves
|
||||
```python
|
||||
print(mi_diccionario["recursos"][1])
|
||||
```
|
||||
|
||||
"ejercicios"
|
||||
|
||||
Métodos para listar los nombres de:
|
||||
|
||||
| Método | Descripción |
|
||||
| :-------: | :-------------------- |
|
||||
| keys( ) | las claves |
|
||||
| values( ) | los valores |
|
||||
| items( ) | los pares clave:valor |
|
||||
|
||||
*: 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.
|
||||
|
||||
Cuidado, las claves no se pueden repetir.
|
||||
## 3.7. - Tuples
|
||||
|
||||
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
|
||||
**unpacking** (extracción de datos)
|
||||
```python
|
||||
a, b, c, d = mi_tuple
|
||||
print(c)
|
||||
```
|
||||
|
||||
[3.33, "cuatro"]
|
||||
|
||||
## 3.8. - sets
|
||||
|
||||
Los sets son otro tipo de estructuras de datos. Se diferencian de 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
|
||||
```python
|
||||
mi_set_c = mi_set_b.symmetric_difference(mi_set_a)
|
||||
print(mi_set_c)
|
||||
```
|
||||
|
||||
{1, 2, 3}
|
||||
|
||||
|
||||
|
||||
**symmetric_difference_update(set)** elimina los elementos comunes a A y B, agregando los que no están presentes en ambos a la vez
|
||||
```python
|
||||
mi_set_b.symmetric_difference_update(mi_set_a)
|
||||
print(mi_set_b)
|
||||
```
|
||||
|
||||
{1, 2, 3}
|
||||
|
||||
|
||||
|
||||
**union(set)** retorna un set resultado de combinar A y B (los datos duplicados se eliminan)
|
||||
```python
|
||||
mi_set_c = mi_set_a.union(mi_set_b)
|
||||
print(mi_set_c)
|
||||
```
|
||||
|
||||
{1, 2, 3, 'tres'}
|
||||
|
||||
|
||||
|
||||
**update(set)** inserta en A los elementos de B
|
||||
```python
|
||||
mi_set_a.update(mi_set_b)
|
||||
print(mi_set_a)
|
||||
```
|
||||
|
||||
{1, 2, 3, 'tres'}
|
||||
|
||||
|
||||
|
||||
## 3.9. - booleanos
|
||||
|
||||
Los booleanos son tipos de datos binarios (True/False), que surgen de operaciones lógicas, o pueden declararse explícitamente.
|
||||
|
||||
### 3.9.1. - operadores lógicos
|
||||
|
||||
| Operador | Descripción |
|
||||
| :------: | :------------------------------------------- |
|
||||
| `==` | igual a |
|
||||
| `!=` | no igual a |
|
||||
| `>` | mayor que |
|
||||
| `<` | menos que |
|
||||
| `>=` | mayor o igual a |
|
||||
| `<=` | menor o igual a |
|
||||
| `and` | y (True si dos declaraciones son True) |
|
||||
| `or` | o (True si al menos una declaración es True) |
|
||||
| `not` | no (invierte el valor del booleano |
|
||||
|
||||
## 3.10. - Proyecto del Día 3
|
||||
|
||||
Analizador de texto.
|
||||
|
||||
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.
|
||||
|
||||
## Ficheros y documentación del día 3
|
||||
- [01_index.py](01_index.py)
|
||||
- [02_sub_strings.py](02_sub_strings.py)
|
||||
- [03_metodos.py](03_metodos.py)
|
||||
- [04_string.py](04_string.py)
|
||||
- [05_propiedades.py](05_propiedades.py)
|
||||
- [06_listas.py](06_listas.py)
|
||||
- [07_diccionarios.py](07_diccionarios.py)
|
||||
- [08_tuplas.py](08_tuplas.py)
|
||||
- [09_set.py](09_set.py)
|
||||
- [10_booleanos.py](10_booleanos.py)
|
||||
- [11_programa03.py](11_programa03.py)
|
||||
- [__pycache__](__pycache__)
|
||||
|
||||
[Documentación del día](../doc_curso/03_analizador_de_texto/)
|
||||
|
||||
---
|
||||
|
||||
Enlaces a todos los días: [dia 1 - creador de nombres](../dia_01/README.md) / [dia 2 - calculador de comisiones](../dia_02/README.md) / [dia 3 - analizador de texto](../dia_03/README.md) / [dia 4 - juego "adivina el número"](../dia_04/README.md) / [dia 5 - juego "El ahorcado"](../dia_05/README.md) / [dia 6 - recetario](../dia_06/README.md) / [dia 7 - cuenta bancaria](../dia_07/README.md) / [dia 8 - consola de turnos](../dia_08/README.md) / [dia 9 - buscador de números de serie](../dia_09/README.md) / [dia 10 - juego "Invasión espacial"](../dia_10/README.md) / [dia 11 - web scraping](../dia_11/README.md) / [dia 12 - gestor de restaurantes](../dia_12/README.md) / [dia 13 - asistente de voz](../dia_13/README.md) / [dia 14 - controlador de asistencia](../dia_14/README.md) / [dia 15 - machine learning](../dia_15/README.md) / [dia 16 - aplicación web de tareas pendientes](../dia_16/README.md)
|
||||
Reference in New Issue
Block a user