Seminario-de-Lenguajes-Python

💻Practica 2

Seminario de Lenguaje Python 2022

2.1 Parte 1

Recordar: * split(): ¿qué caracter utilizarían para separar? * string in frase: para saber si un substring está incluido dentro de una frase * ¿podemos preguntar si un string se encuentra en una frase antes de recorrer la lista de palabras?

texto = """The constants defined in this module are:The constants defined in␣
,→this module are:
string.ascii_letters
The concatenation of the ascii_lowercase and ascii_uppercase constants␣
,→described below. This value is not locale-dependent.
string.ascii_lowercase
The lowercase letters 'abcdefghijklmnopqrstuvwxyz'. This value is not␣
,→locale-dependent and will not change.
string.ascii_uppercase
The uppercase letters 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'. This value is not␣
,→locale-dependent and will not change.
"""
## lista con todas las palabras
print(texto.lower().split())
# lista con palabras sin repetir
print(set(texto.lower().split()))

['the', 'constants', 'defined', 'in', 'this', 'module', 'are:the', 'constants',
'defined', 'in', 'this', 'module', 'are:', 'string.ascii_letters', 'the',
'concatenation', 'of', 'the', 'ascii_lowercase', 'and', 'ascii_uppercase', 'constants', 'described', 'below.', 'this', 'value', 'is', 'not', 'localedependent.', 'string.ascii_lowercase', 'the', 'lowercase', 'letters',
"'abcdefghijklmnopqrstuvwxyz'.", 'this', 'value', 'is', 'not', 'localedependent', 'and', 'will', 'not', 'change.', 'string.ascii_uppercase', 'the',
'uppercase', 'letters', "'abcdefghijklmnopqrstuvwxyz'.", 'this', 'value', 'is',
'not', 'locale-dependent', 'and', 'will', 'not', 'change.']
{'string.ascii_uppercase', 'value', 'concatenation', 'ascii_lowercase', 'is',
'are:', 'ascii_uppercase', 'constants', 'locale-dependent.', 'and',
'string.ascii_letters', 'uppercase', 'this', 'of', 'string.ascii_lowercase',
'below.', 'locale-dependent', 'change.', 'defined', 'lowercase', 'the',
'module', 'not', 'are:the', "'abcdefghijklmnopqrstuvwxyz'.", 'will', 'in',
'described', 'letters'}

Investigue el módulo Counter para simplificar la resolución

2.1.1 Identificando mayúsculas, minúsculas y caracteres no letras

caracter = "T"
print(texto.split()[0].startswith(caracter))

¿Pero qué pasa si queremos saber indistintamente si la palabra comienza con dicha letra en minúscula o mayúscula?

caracter = "t"
print(texto.lower().split()[0].startswith(caracter))

¿Y si el caracter ingresado no es una letra?

import string
caracter = "?"
print(f"El caracter es una letra {caracter in string.ascii_letters}")

evaluar = """ título: Experiences in Developing a Distributed Agent-based Modeling Toolkit withresumen: Distributed agent-based modeling (ABM) on high-performance computing resources provide"""

En este ejemplo debería informar:

Notas: * investigue Pattern Matching para una solución simplificada. * ¿cuántas variables utilizó para guardar la cantidad de cada categoría, se podría usar alguna estructura?

Ejemplo 1

Ejemplo 2

Ejemplo 3

2.2 Parte 2

cadena = input("Ingresa la clave (debe tener menos de 10 caracteres y no␣ ,→contener los símbolos:@ y !):")
if len(cadena) > 10:
    print("Ingresaste más de 10 carcateres")
cant = 0
for car in cadena:
    if car == "@" or car == "!":
        cant = cant + 1
if cant >= 1:
    print("Ingresaste alguno de estos símbolos: @ o !" )
else:
    print("Clave válida")

¿Cómo podemos simplificarlo?

frase = """
Si trabajás mucho CON computadoras, eventualmente encontrarás que te gustaría
automatizar alguna tarea. Por ejemplo, podrías desear realizar una búsqueda y
reemplazo en un gran número DE archivos de texto, o renombrar y reorganizar
un montón de archivos con fotos de una manera compleja. Tal vez quieras
escribir alguna pequeña base de datos personalizada, o una aplicación
especializada con interfaz gráfica, o UN juego simple.
"""

Tener en cuenta - Lo que no se puede repetir en la frase son sólo aquellos caracteres que sean letras. - No se distingue entre mayúsculas y minúsculas, es decir si en la frase o palabra tenemos la letra T y la letra t la misma NO será un Hererograma. - Para simplificar el ejercicio vamos a tomar como que las letras con tilde y sin tilde son distintas. Ya que Python las diferencia:

>>> 'u' == 'ú'
Entrada ¿Heterograma?
cruzamiento Si
centrifugados Si
portón Si
casa No
día de sol No
con diez uñas Si
no-se-duplica Si
Letra Valor
A, E, I, O, U, L, N, R, S, T 1
D, G 2
B, C, M, P 3
F, H, V, W, Y 4
K 5
J, X 8
Q, Z 10

*Tenga en cuenta qué estructura elige para guardar estos valores en Python

Ejemplo 1

Ejemplo 2

9) La idea es tratar de programar una de las partes principales del juego Buscaminas. La idea es que dado una estructura que dice que celdas tienen minas y que celdas no las tienen, como la siguiente: Resolución

[
'-*-*-',
'--*--',
'----*',
'*----',
]

Generar otra que indique en las celdas vacías la cantidad de bombas que la rodean, para el ejemplo anterior, sería:

[
'1*3*1',
'12*32',
'1212*',
'*1011',
]

Nota: Defina al menos una función en el código (si hay mas mejor) y documente las mismas con docstring que es lo que hacen.

Manipule estos archivos para realizar lo siguiente:

3 Segunda entrega

Ejercicio_1

import os
clear = lambda: os.system('cls')
clear()
archivo = open("readme.txt","r")
links = []
for linea in archivo:
    if ("https" in linea)  :
        links.append(linea)
print(links)
archivo.close()

Ejercicio_2

texto = """The constants defined in this module are:The constants defined in␣
,→this module are:
string.ascii_letters
The concatenation of the ascii_lowercase and ascii_uppercase constants␣
,→described below. This value is not locale-dependent.
string.ascii_lowercase
The lowercase letters 'abcdefghijklmnopqrstuvwxyz'. This value is not␣
,→locale-dependent and will not change.
string.ascii_uppercase
The uppercase letters 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'. This value is not␣
,→locale-dependent and will not change.
"""
from collections import Counter

list_of_words=texto.lower().split()
c = Counter(list_of_words)
c.most_common(1)
print ("",c.most_common(1))

Ejercicio_3

texto = """The constants defined in this module are:The constants defined in␣
,→this module are:
string.ascii_letters
The concatenation of the ascii_lowercase and ascii_uppercase constants␣
,→described below. This value is not locale-dependent.
string.ascii_lowercase
The lowercase letters 'abcdefghijklmnopqrstuvwxyz'. This value is not␣
,→locale-dependent and will not change.
string.ascii_uppercase
The uppercase letters 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'. This value is not␣
,→locale-dependent and will not change.
"""
letra = input("Ingrese una letra: ")

SinRepe = (set(texto.lower().split()))
#mas cortes
for dato in SinRepe:
    if (dato[0].startswith(letra)):
        print(dato)

Ejercicio_4

from cgitb import text
from posixpath import split
from time import process_time_ns

texto = """título: Experiences in Developing a Distributed Agent-based Modeling Toolkit with Python.
resumen: Distributed agent-based modeling (ABM) on high-performance computing resources provides the promise of capturing unprecedented details of large-scale complex systems.
However, the specialized knowledge required for developing such ABMs creates barriers to wider adoption and utilization. Here we present our experiences in developing an initial
implementation of Repast4Py, a Python-based distributed ABM toolkit. We build on our experiences in developing ABM toolkits, including Repast for High Performance Computing
(Repast HPC), to identify the key elements of a useful distributed ABM toolkit. We leverage the Numba, NumPy, and PyTorch packages and the Python C-API to create a scalable modeling
syste"""

list_valores  = [0,0,0,0]
titulo = (((texto.split("\n")[0])).split()) #Saco el titulo
titulo.remove(titulo[0]) #Elimino el primer elemento que no cuenta para el titulo
#Usar el remplace('')
if (len(titulo)<=10):
    print("Titulo esta ok")

oraciones = texto.split(".")
oraciones.remove(oraciones[0]) #Elimino el titulo

for oracion in oraciones:
    if (len((oracion).split()) <= 12):
        list_valores [0]+=1
    elif((len((oracion).split()) >= 13) & (len((oracion).split()) <=17) ): 
        list_valores [1]+=1
    elif((len((oracion).split())>= 18) & (len((oracion).split()) <=25) ): 
        list_valores [2]+=1
    elif (len((oracion).split())>25):
        list_valores [3]+=1

print("Cantidad de oraciones fáciles de leer:", list_valores[0]," aceptables para leer:", list_valores[1], "dificil de leer: ",list_valores[2]," muy dificil de leer:" ,list_valores[3])

#Pattern Matching

Ejercicio_5

Frase = input("Ingrese una frase: ")
palabra = input("Ingrese una palabra: ")
Frase = Frase.lower()
palabra = palabra.lower()
Datos = Frase.count(palabra)
print('La cantidad de ocurrencias es:', Datos)

Ejercicio_5_2

import re
cadena = "aaaaaaaaaa@!"
cumple = (len(cadena)>=10) & bool(re.search(r'@', cadena)) & bool(re.search(r'!', cadena))
if cumple:
    print("Contra Correcta")
#falta esto :( print("Ingresaste alguno de estos símbolos: @ o !" )
#count

Ejercicio_6

frase = """
Si trabajás mucho CON computadoras, eventualmente encontrarás que te gustaría
automatizar alguna tarea. Por ejemplo, podrías desear realizar una búsqueda y
reemplazo en un gran número DE archivos de texto, o renombrar y reorganizar
un montón de archivos con fotos de una manera compleja. Tal vez quieras
escribir alguna pequeña base de datos personalizada, o una aplicación
especializada con interfaz gráfica, o UN juego simple.
"""

lista = set((frase.lower()).split())
for palabra in lista:
    print(palabra)

Ejercicio_7

palabra = "Escriba"#o frase 
#Hacer un split de las palabras
#identificar si es una palabra o una frase
#filter.count(caracteres)
print(len(palabra))
repetida = False
contador = 0
while (repetida == False)& (contador <len(palabra)):
    if (palabra.count(palabra[contador])>1):
        repetida = True
    contador+=1
#Uso filter
if repetida:
    print("La palabra no es un Heterograma")
else:
    print("La palabra es un Heterograma")

#if len(set(palabra)) != len (palabra):
#    print('no es heterograma)
#else:
#    print('es heterograma'

Ejercicio_8

tabla = {"aeioulnrst":1,"dg":2,"bcmp":3,"fhvwy":4,"k":5,"jx":8,"qz":10}

palabra = "tomate"
total = 0
for letra in palabra:
    if letra in tabla:
        total+=tabla[letra]* letra.count(letra)
print(total)
#Accedo directo
#tratar de usar filter
#yield

Ejercicio_9

celdas = [
'-*-*-',
'--*--',
'----*',
'*----'
]
celdas = [list(col) for col in celdas]
def GuardarNumero(fila, columna):
    cant = 0

    Empieza_Fila = 0 if fila == 0 else -1
    Termina_Fila = 1 if fila == 3 else 2

    Empieza_Columna = 0 if columna == 0 else -1
    Termina_Columna = 1 if columna == 4 else 2

    for i in range(Empieza_Fila, Termina_Fila):
        for j in range(Empieza_Columna, Termina_Columna):
            if celdas[fila + i][columna + j] == "*":
                cant += 1
    return cant



x = 0
y = 0
print(celdas)
celdas_bombas = []
print("_"*30)
print("Las siguientes celdas tienen bombas")
for celda in celdas:
    x = 0
    for bomba in celda:
        if (bomba=="-"):
            celdas[y][x] = GuardarNumero(y,x)
            celdas_bombas.append([y,x])
            #print("La celda [", y,"],[",x,"] ")
        x+=1
    y+=1
#Pattern Matching 
print("_"*30)
print(celdas_bombas)

print(celdas)

Ejercicio_10

import string


f = open ('eval1.txt','r')
notas = ((f.read()).split("\n"))
f.close()
for index, nota in enumerate(notas):
    notas[index] = ((nota.replace(",","")))
#zip
#readline
notas.pop(-1) #Elimine el ultimo elemento ya que no me dejaba convertirlos porque era un string
int_list = list(map(int, notas))

f = open ('eval2.txt','r')
notas2 = ((f.read()).split("\n"))
f.close()
for index, nota in enumerate(notas2):
    notas2[index] = nota.replace(",","")

notas2.pop(-1)
int_list2 = list(map(int, notas2))


nuevasNotas:list[int] = []
for i in range(len(int_list)):
	nuevasNotas.append(int_list[i]+int_list2[i])

print(nuevasNotas)
# [111, 155, 100, 108, 99, 134, 78, 121, 33, 53, 74, 13, 48, 101, 106, 128, 97, 106, 76, 90, 21, 173, 62, 79, 100, 68, 142, 112, 87, 146, 148, 55, 140, 109, 103, 110, 137, 114, 65, 22, 105, 99, 24, 139, 126, 120, 84]

#_____________________________________________________


f = open ('nombres_3.txt','r')
nombres = ((f.read()).split("\n"))
f.close()
for index, nombre in enumerate(nombres):
    nombres[index] = ((nombre.replace(",","")))

print(nombres)

dict_from_list = dict(zip(nombres,nuevasNotas ))
print(dict_from_list)

promedio = sum(nuevasNotas) / len(nuevasNotas)
print(promedio)



for clave, valor in dict_from_list.items():
    if valor> promedio:
        print(clave)

Ejercicio_11

f = open ('eval1.txt','r')
notas = ((f.read()).split("\nro1"))
f.close()
for index, nota in enumerate(notas):
    notas[index] = ((nota.replace(",","")))

notas.pop(-1) #Elimine el ultimo elemento ya que no me dejaba convertirlos porque era un string
int_list = list(map(int, notas))

f = open ('eval2.txt','r')
notas2 = ((f.read()).split("\nro1"))
f.close()
for index, nota in enumerate(notas2):
    notas2[index] = nota.replace(",","")

notas2.pop(-1)
int_list2 = list(map(int, notas2))


nuevasNotas = []
for i in range(len(int_list)):
	nuevasNotas.append(int_list[i]+int_list2[i])

print(nuevasNotas)
# [111, 155, 100, 108, 99, 134, 78, 121, 33, 53, 74, 13, 48, 101, 106, 128, 97, 106, 76, 90, 21, 173, 62, 79, 100, 68, 142, 112, 87, 146, 148, 55, 140, 109, 103, 110, 137, 114, 65, 22, 105, 99, 24, 139, 126, 120, 84]

#_____________________________________________________


f = open ('nombres_3.txt','r')
nombres = ((f.read()).split("\nro1"))
f.close()
for index, nombre in enumerate(nombres):
    nombres[index] = ((nombre.replace(",","")))

print(nombres)

f = open ('nombres_2.txt','r')
nombres2 = ((f.read()).split("\nro1"))
f.close()
for index, nombre in enumerate(nombres2):
    nombres2[index] = ((nombre.replace(",","")))

print(nombres2)

nombresRepetidos = [nro1 for nro1 in nombres for nro2 in nombres2 if nro1 == nro2]
print("Nombres repetidos:", nombresRepetidos)

print("   {:<15} {:<10} {:<10} {:<10}".format("NOMBRE", "EVAL1", "EVAL2", "TOTAL"))
for i, estudiante in enumerate(zip(nombres, notas, notas2)):
    nombre, nota1, nota2 = estudiante
    nota1, nota2 = int(nota1), int(nota2)

    print(
        "{:<} {:<18} {:<10} {:<10} {:<10}".format(
            i, nombre, nota1, nota2, nota1 + nota2
        )
    )