UNIVERSIDAD NACIONAL

AUTÓNOMA DE MÉXICO

FACULTAD DE ESTUDIOS SUPERIORES

“ARAGÓN”

Tarea 1

Compiladores

(Semestre 2020-II)

M. en C. Marcelo Pérez Medel

Febrero, 2019
Contenido
1. Introducción de Python ..................................................................................... 3

1.1. Instalación de Python en Windows ............................................................ 3

1.2. Historia, filosofía y aspectos básicos de Python ........................................ 7

1.3. Tipos de dato ........................................................................................... 12

1.4. Tipos de operadores ................................................................................ 13

1.5. Estructuras de control .............................................................................. 14

1.6. Archivos ................................................................................................... 18

1.7. Funciones................................................................................................. 21

1.8. Listas ........................................................................................................ 22

2. Ejercicios. ....................................................................................................... 24
 1. Introducción de Python
Python es un lenguaje de programación interpretado, una de sus ventajas es el
manejo de un código legible y sencillo. La lógica de programación puede ser
utilizada para aplicarse con otros lenguajes realizando cambios mínimos en los
mismos.

1.1. Instalación de Python en Windows

Para este curso, se va a utilizar la versión de Python 3.7.2. y el proceso para
instalarlo es muy sencillo. Lo primero que se debe hacer es acceder a la página de
Python:

https://www.python.org/downloads/

Y buscamos la versión correspondiente para instalar.

Figura 1.1.1. Página para descargar el ejecutable de Python 3.7.2.

Ya seleccionada la versión a descargar, se procede a seleccionar el archivo
correspondiente al Sistema Operativo y se procede a instalar como un programa
nuevo.
Figura 1.1.2. Eligiendo el archivo ejecutable para instalarse.

Figura 1.1.3. Instalación desde un inicio de Python.

 Figura 1.1.4. Instalando Python.

Figura 1.1.5. ¡Python ya ha sido instalado!

Ya se tiene instalado todo para trabajar, pero falta un pequeño paso más para una
mejor comodidad al acceder a Python. Desde el menú de buscar en Windows, se
requiere buscar la palabra “IDLE” y que sea la versión que se haya instalado.

Figura 1.1.6. Buscando el IDLE para trabajar en Python 3.7.

Si se selecciona la versión correcta, finalmente podremos obtener la Figura 1.1.7. y

el entorno para trabajar en Python ya estará listo.
 Figura 1.1.7. ¡Python está listo para comenzar a trabajar!

1.2. Historia, filosofía y aspectos básicos de Python

A finales de los años 80’s, Python fue creado por Guido van Rossum en el Centro
para las Matemáticas y la Informática en los Países Bajos. Su nombre proviene de
la afición del creador por los humoristas británicos Monty Python. El enfoque
filosófico es tomado de Tim Peters (1999), quien describe lo siguiente:

“Bello es mejor que feo.

Explícito es mejor que implícito.
Simple es mejor que complejo.
Complejo es mejor que complicado.
Plano es mejor que anidado.
Disperso es mejor que denso.
La legibilidad cuenta.
Los casos especiales no son tan especiales como para quebrantar las reglas.
Lo práctico gana a lo puro.
Los errores nunca deberían dejarse pasar silenciosamente.
A menos que hayan sido silenciados explícitamente.
Frente a la ambigüedad, rechaza la tentación de adivinar.
Debería haber una (y preferentemente sólo una) manera obvia de hacerlo.
Aunque esa manera puede no ser obvia al principio a menos que usted sea
holandés.
Ahora es mejor que nunca.
Aunque “nunca” es a menudo mejor que “ya mismo”.
Si la implementación es difícil de explicar, es una mala idea.
Si la implementación es fácil de explicar, puede que sea una buena idea.
Los espacios de nombres (namespaces) son una gran idea. ¡Hagamos más de esas
cosas!”

Dicha ideología es implementada en la consola de comandos también llamada

Shell. Para ello, se ejecuta la instrucción import this, el ejemplo se presenta en la
figura 1.2.1.

Figura 1.2.1. Ideología de Python en el Shell.

Python cuenta con varias características, algunas de las más importantes son:
 Tipado dinámico: La mayoría de lenguajes debe pasar por dos etapas para
declarar variables:
 1. Colocar el nombre y el tipo de dato de la variable.
2. Asignar un valor de acuerdo al tipo de dato especificado
anteriormente.
Sin embargo, Python realiza estas dos etapas en una sola, esto es, el tipo de
dato se establece de forma automática dependiendo del dato asignado.
Además, es capaz de modificar el tipo posteriormente si se requiere.
 Indentación: Para delimitar bloques de código, como sentencias, funciones o
bucles, Python utiliza dos puntos “:” como delimitadores al inicio de su
cuerpo, siendo el sangrado la representación del inicio y final del mismo.
 Multiparadigma: Permite que los programadores adopten diferentes estilos
de programación:
 Programación Estructurada.- El programa se debe escribir de tal forma
que las instrucciones se ejecutarán de modo descendente, es decir,
describe lo que las instrucciones deben hacer para resolver un
problema de forma lineal. Es el paradigma más básico y fácil de
comprender.
 Programación Funcional.- Trata de definir las cosas, por ejemplo para
resolver problemas por medio de la creación de funciones, las cuales
deben tener un nombre clave que describa lo que hace, cero o más
entradas para que trabaje, además de un posible valor final para
devolver. Las funciones se pueden utilizar las veces necesarias en el
momento que se requiera.
 Programación Orientada a Objetos.- Define los programas en términos
de comunidades de objetos, los cuales tienen cada uno una serie de
atributos y métodos que lo caracterizan, gracias a una clase base
desde la cual se establece su creación.

Python cuenta con un intérprete de comandos llamado Shell o simplemente una

terminal, la cual sirve para que ejecute las instrucciones que se ingresan de forma
inmediata. A continuación, se muestra en la figura 1.2.2. su aspecto.
 Figura 1.2.2 Shell o terminal de Python.

También se cuenta con la posibilidad de crear scripts, es decir, archivos de código

fuente que se pueden ejecutar en el Shell cuantas veces sean necesarias. Esto se
puede hacer desde la pestaña File  New Window. La explicación de las
instrucciones se presenta a continuación y posteriormente se presenta el script en
la figura 1.2.3.
 El primer renglón tiene la palabra reservada print, seguida de la cadena
“Hola”, haciendo que se imprima en una sola línea.
 El segundo imprime la cadena “Mundo” en una línea.
 El tercero imprime la misma cadena “Hola”, pero con la diferencia de que hay
un argumento extra llamado end, indicando que deje el cursor adelante con
un espacio y siga imprimiendo lo que sigue, siempre y cuando haya más para
imprimir.
 Al igual que el segundo renglón, el cuarto vuelve a imprimir la cadena
“Mundo”. Como no hay una coma al final, realiza un salto de línea para otra
línea nueva.
 El quinto crea una variable llamada “variable” con el valor igualado a una
cadena “valor”. Esta es la forma de crear una variable con su respectivo valor
en Python.
 El sexto y último renglón imprime el valor de la variable ingresada.
 Figura 1.2.3 Ventana para crear scripts que Python podrá ejecutar.

Para ver el resultado del script anterior, se puede hacer desde la pestaña Run 
Run Module o también presionando la tecla F5. El resultado de la ejecución se
muestra en la figura 1.2.4.

Figura 1.2.4 Resultado de la ejecución del script anterior.

Cuando el código de un programa se extiende demasiado, o lo revisa otro

programador, es difícil entender lo que realizó el autor porque su ideología puede
ser diferente a la del revisor. Por ello, una buena práctica es colocar comentarios
para facilitar la comprensión del código.
Un comentario es una parte de código que un lenguaje de programación ignora al
momento de ejecutarse, pero es útil para conocer su funcionamiento por parte de
otro programador o el autor del mismo. Para colocar comentarios en Python, existen
dos formas:
1. Después de colocar un símbolo de gato “#”, toda la línea se vuelve un
comentario.
2. Colocando tres comillas simples “’” o comillas dobles “”” hará que todo lo que
se escriba a continuación, sea comentado, incluyendo los saltos de línea. Si
 se desea terminar de comentar, se vuelven a escribir comillas simples o
dobles, dependiendo de las que se usaron al inicio.

A continuación, se presenta un ejemplo de uso de comentarios.

# -*- coding: cp1252 -*-

# Esto es un comentario simple.
print("Esto sí se imprime.")
""" Comentario
de varias
líneas."""

Una vez más, se ejecuta el script anterior para obtener el resultado de la figura 1.2.5.

Figura 1.2.5 Los comentarios no se ven en la ejecución del programa, sólo son para el
programador.

1.3. Tipos de dato

Python tiene los siguientes tipos de dato primitivos:

 Booleanos (bool): Aquellos con 2 valores únicos: True o False.

 Enteros (int): Son los números naturales simples: 2, 9, 4, -1.
 Reales (float): Aquellos que tienen un valor decimal o punto: 3.1416, 0.5.
 Cadena (str): Conjunto de caracteres que forman una palabra. Se deben
colocar entre comillas simples o dobles: “Compilador”, “Grupo”, “Uno”.
 Figura 1.3.1. Mostrando los tipos de datos básicos.

1.4. Tipos de operadores

Los operadores son útiles para realizar diferentes objetivos:
 Operadores de comparación, como su nombre lo indica, permiten comparar
dos valores (<, >, ==, !=, etc.).
 Operaciones aritméticas básicas, como lo son la suma, resta, multiplicación
y división (+, -, *, /, etc.).
 Comparaciones lógicas, agrupa varias condiciones que se deben o no
cumplir. La evaluación se realiza en forma booleana, esto es, verdadero o
falso (and, or, not).
 Figura 1.4.1. Probando diferentes operadores en Python.

1.5. Estructuras de control

En cualquier lenguaje es indispensable conocer que existen diferentes flujos que
puede tomar un programa, o bien, se necesita que se repita un determinado número
de veces un código para obtener un resultado.

La primera estructura que se mostrará es la de decisiones, cuyo pseudocódigo

resulta ser el siguiente:

Si una condición es verdadera:

Cuerpo de la sentencia.
De lo contrario si otra condición se cumple:
Cuerpo de la sentencia.
De lo contrario si otra condición se cumple:
Cuerpo de la sentencia.
De lo contrario si…
Cuerpo de la sentencia.
De lo contrario:
Cuerpo de la sentencia por completo.
En lenguaje de Python esto resulta tener la siguiente estructura:

if(condicion):
Cuerpo del if.
elif(condicion):
Cuerpo del elif.
elif…:
Cuerpo del elif.
else:
Cuerpo del else.
Un ejemplo para comprender esta estructura sería el siguiente:

Realizar un programa que solicite al usuario ingresar un número. Si resulta ser mayor o
igual a 18, imprimir que es un mayor de edad, pero si no, es un menor de edad. También se
debe tener en cuenta lo que pase si se ingresan números negativos.

Si se requiere obtener un dato del usuario por medio del Shell de Python, se requiere
usar la sintaxis:

variable = input(“Mensaje para mostrar”)

En un primer intento se puede tener un código como el de la figura 1.5.1.

Figura 1.5.1. Programa que simula el problema de la edad.

Si se corre este programa, obtendremos el resultado de la figura 1.5.2.
 Figura 1.5.2. Parece que hay un error en el programa.

Lo que está ocurriendo es que el programa toma a lo que envía el usuario como una
cadena, pero en este caso se necesita un valor del tipo entero. Esto no es de
preocuparse mucho, ya que necesitamos tener en cuenta el concepto de “casteo”,
lo cual resulta de cambiar el tipo de dato al que se desee. Esto se realiza en Python
con la forma:

clase_de_tipo_de_dato(dato)
De tal forma que lo único que se necesita modificar en el código anterior sería la
línea que solicita la edad del usuario para que sea “casteada” a un valor entero.

Figura 1.5.3. Ahora se convierte al tipo de dato entero que se necesita en el cuerpo de la
sentencia de control.

Al correr de nuevo el programa de varias formas con diferentes edades, se pueden

obtener los siguientes resultados como los de la figura 1.5.4.
 Figura 1.5.4. Ingresando diferentes edades generan diferentes resultados.

Ahora, las siguientes estructuras se les denominan repetitivas o iterativas, debido a

que se ejecutan un determinado número de veces para llegar a un resultado. Python
maneja 2 de estas estructuras:

- while (mientras): Tiene como peculiaridad que esta estructura se repetirá

mientras que alguna condición se cumpla. Debe tenerse cuidado que esta
condición cambie constantemente, ya que si no, puede quedarse el programa
en un ciclo infinito.
La estructura de un while es:

while(condicion):
Cuerpo del while…
- for (para): Esta estructura trabaja con un conjunto de elementos que
pueden iterarse uno a uno, el cual puede resultar ser varios tipos de datos
como una lista, cadena, entre otros datos.
La estructura de un for es:

for variable in conjunto_elementos:

Cuerpo del for…

Para comprender mejor esta nueva estructura, se procede a ver un ejemplo:

Mostrar los números del 1 hasta el 100.

El script que puede resolver este problema se hará con las 2 estructuras vistas,
llegando al mismo resultado.

Figura 1.5.5. Script que imprime los números del 1 al 100 con 2 estructuras iterativas.

Obsérvese que en el ciclo for se usa la sentencia:

range(entero)
Esto simplemente resulta devolver una lista de números que van del 0 a entero –
1. Aclarado este asunto, si se corre el script, se obtiene el siguiente resultado.

Figura 1.5.6. Secuencia de números con 2 estructuras diferentes.

1.6. Archivos
De la misma forma, se verán rápidamente la creación y lectura de archivos de texto
plano. En Python es muy sencillo hacer esto porque se necesitan tener en mente 3
sencillos pasos para cualquier tipo de archivo:
  Crear el archivo desde su ruta y saber qué tipo de archivo es.
 Realizar las operaciones correspondientes.
 Cerrar el archivo para que se pueda usar por otros programas al terminar.

Teniendo esto en mente, se procede a crear un archivo de ejemplo, que contenga

el siguiente contenido:

Compiladores
2019-II

Primero, se debe crear el archivo que almacenará en una variable con la sintaxis:

archivo = open(“ruta_archivo.ext”, ‘atributo’)

El parámetro de ‘atributo’ tomará diversos valores dependiendo del uso que se vaya
a dar (‘w’ = escritura, ‘r’ = lectura). En este caso, se necesita crear un archivo, así
que el archivo que se debe crear tendrá un aspecto parecido al siguiente:

archivo = open(“ej_1.txt”, ‘w’)

Ya que se hizo esto, se procede a crear el contenido del archivo con lo mencionado
anteriormente con el método:

archivo.write(“Contenido”)
Si se quiere un salto de línea, se ingresa con la secuencia de escape ‘\n’.

Y finalmente se necesita cerrar el archivo creado para que no haya problemas al

ser usado por otra aplicación con el método:

archivo.close()

El aspecto del script correspondiente puede ser como el de la figura 1.6.1.

 Figura 1.6.1. Creando un archivo de prueba y escribiendo su contenido.
De acuerdo a la ruta donde se ha creado este archivo, podemos abrirlo y ver su
contenido.

Figura 1.6.2. Contenido del archivo creado.

Ahora, si se quiere obtener el contenido de algún archivo externo, la idea va a ser
exactamente la misma, pero variará en los siguientes aspectos:

 El parámetro ‘atributo’ al crear el archivo será esta vez ‘r’ de lectura.

 En lugar de usar el método write(“contenido”), se usa el método read() para
obtener el contenido del archivo.

Por lo tanto, el programa para leer el archivo que se ha creado previamente, puede
tener el aspecto de la figura 1.6.3.

Figura 1.6.3. Script que lee el contenido de un archivo existente.

Al ejecutar este programa, se obtendrá el resultado de la figura 1.6.4.
 Figura 1.6.4. Obteniendo el contenido del archivo creado anteriormente en el Shell.

1.7. Funciones
Una función en la programación no es más que una parte de código que trabaja
cuando se le llama desde cualquier parte del programa. Al final, una función puede
devolver o no un resultado final, dependiendo del objetivo para la cual fue diseñada.

La estructura en Python para una función sencilla es la siguiente:

def nombreFuncion(parametros):
Cuerpo de la función.
Si se requiere que la función devuelva algún resultado, se deberá tener en cuenta
que al final del cuerpo de la misma debe usarse la sentencia:

return valor

Ahora, veamos el siguiente ejemplo para comprender mejor este concepto:

Diseña una función que devuelva el área de un rectángulo dada su base y altura.

La estructura que puede tener la función que nos ayudará a resolver este problema
puede tener la estructura de la figura 1.7.1.

Figura 1.7.1. Función que calcula el área de un rectángulo.

Si se quiere llamar a esta función, una vez que se ejecute el script, se puede hacer
uso de esta función cuantas veces sean de la siguiente forma:

nombreFuncion(parametros)

Figura 1.7.2. Llamando a la función creada con parámetros diferentes.

1.8. Listas
Una lista es un tipo de dato que maneja Python, que tiene la ventaja de almacenar
otros tipos de datos en sí misma (incluso otras listas mismas). La forma de declarar
una lista es abriendo y cerrando un par de corchetes con la siguiente sintaxis:

lista = []
Algunas de las funciones que puede hacer una lista es:

 Conocer el tamaño de la lista (o cualquier otra estructura con conjunto de

elementos):

len(lista)
 Remover el objeto seleccionado como índice (por defecto, si no se manda
algún parámetro, se retira el último elemento):

lista.pop(indice)
 Limpiar la lista eliminando todos sus elementos:

lista.clear()
 Ordenar los elementos:

lista.sort()
 Acceder a un elemento en específico:

lista[indice]
Figura 1.8.1. Algunos métodos de una lista.
 2. Ejercicios.
Ya que se ha mostrado un poco de Python en general y para una mejor comprensión
y conocimiento, a continuación para la tarea 1 se dejarán unos ejercicios en los que
se deben practicar los temas vistos y mandar el código que se utilice en caso de ser
necesario, así como el resultado final.

1. Haz un programa que pida al usuario por el Shell una letra, imprima si es una
vocal o una consonante. Hay que tener en cuenta letras mayúsculas y
minúsculas.

vocales=["a","e","i","o","u"]
consonantes=["b","c","d","f","g","h","j","k","l","m","n","ñ","p",
"q","r","s","t","v","w","x","y","z"]
letra=input("Dame una letra: ")
letra=letra[0]
if letra.lower() in vocales:
print("Es una Vocal")
elif letra.lower() in consonantes:
print("Es una consonante")

2. Haz un programa que imprima el día de la semana con el número

correspondiente que el usuario mande por el Shell:
 1 = Lunes.
 2 = Martes.
 3 = Miércoles.
 4 = Jueves.
 5 = Viernes.
 6 = Sábado.
 0 ó 7 = Domingo.

try:
opcion=int(input("Dame un numero del 0-7: "))
if opcion==1:
print("El día elegido es Lunes")
elif opcion==2:
print("El día elegido es Martes")
elif opcion==3:
print("El día elegido es Miércoles")
 elif opcion==4:
print("El día elegido es Jueves")
elif opcion==5:
print("El día elegido es Viernes")
elif opcion==6:
print("El día elegido es Sábado")
elif opcion==7:
print("El día elegido es Domingo")
elif opcion==0:
print("El día elegido es Domingo")
else:
print("No es una Opción")
except ValueError: print("Ingrese un numero por favor")

3. Haz un programa que realice la sumatoria del 1 al 100 con un ciclo while.

suma=0
cont=0
while cont<101:
suma+=cont
cont+=1
print(suma)

4. Haz un programa que imprima sólo números pares del 1 al 200 con un ciclo
for. Un número es par si su residuo entre 2 resulta 0. En Python se usa la
sintaxis n % m para conocer el residuo de alguna división.

for i in range(0,201):
if i%2==0 and i<200:
print(i,end=", ")
elif i%2==0 and i==200:
print(i)

5. Haz un programa que pida al usuario 10 líneas para que se redacte una carta
y se guarde en un archivo externo con el nombre de “carta_tu_nombre.txt”
(por ejemplo: “carta_Marcelo.txt”).

print("Dame diez lineas de texto para Escribir una Carta: ")

text=""
for i in range(1,11):
 if i==1:
text+=input(str(i)+": ")
else:
text+="\n"+input(str(i)+": ")
archivo=open("carta_JuanM.txt","w")
archivo.write(text)
archivo.close()

6. Haz que un programa lea la carta del ejercicio 5 y la muestre de esta forma:
“Querido usuario, has recibido la carta con este contenido:
<contenido_carta>
Ya no hay más cartas…“

archivo=open("carta_JuanM.txt","r")
text=archivo.read()
print("Querido usuario, has recibido la carta con este contenido: ")
print(text)
print("Ya no hay mas cartas...")
archivo.close()

7. Diseña una función que cuando se mande el parámetro ‘n’, se imprima una
pirámide de asteriscos que cumplan la siguiente lógica:
n=3
*
**
***
n=6
*
**
***
****
*****
******
Para este ejercicio, ten en cuenta que requieres un ciclo anidado, es decir,
un ciclo dentro de otro ciclo.
Opción 1)

aster=int(input("Dame un numero: "))

for i in range(1,aster+1):
for j in range(1,i+1):
print("*",end="")
print("")

Opción 2)

aster=int(input("Dame un numero: "))

for i in range(1,aster+1):
print("*" * i)

8. Crea la función que calcule el perímetro y área de un círculo. Las fórmulas

correspondientes son:

𝑃 = 2𝜋
𝐴 = 𝜋𝑟 2
def perimetro(radio):
return 2*3.1416*radio

def area(radio):
return radio*radio*3.1416

9. Realiza el programa que pida al usuario 10 números que se vayan guardando

en una lista y al final los ordene.

print("Dame diez numeros: ")

ls=[]
for i in range (1,11):
ls.append(float(input(str(i)+": ")))
ls.sort()
for i in ls:
print(i,end=" ")
 10. Como se pudo ver anteriormente, el método para limpiar todos los elementos
en una lista es clear(), pero usando un ciclo y otro método de la misma lista
¿cómo es posible vaciar una lista de esta manera?

R: Con el método pop() que sin un índice mandado de parámetro va eliminando el

último elemento de la lista.

lista=[1,5,8,9,4]
elementos=len(lista)
for i in range(elementos):
lista.pop()
print(lista)

11. El siguiente script se encarga de eliminar comentarios de un archivo de

extensión .java.

Figura 2.1. Script que quita los comentarios de un archivo .java.

También se ha creado una clase de ejemplo para comprobar que el método
funcione llamada “Rectangulo.java”.

Figura 2.2. Contenido de la clase “Rectangulo”.

 El ejercicio consiste simplemente en probar que la función pueda llamar a
este archivo para obtener su contenido y se obtenga un archivo sin
comentarios. Favor de mandar una toma de pantalla del archivo sin
comentarios.

R: Para probarlo mandamos llamar a la función de la siguiente manera:

quitaComentarios("Rectangulo.java","rect2.java")