UNIVERSIDAD NACIONAL DE TRUJILLO

Ingeniería deSistemas

Autómatas y Compiladores

DOCENTE:

Ing. Marcelino Torres Villanueva

TEMA:

Analizador léxico del lenguaje Python

INTEGRANTES:

Mendez Cabrera,Dadky

Polo Reyes, Erika

Quezada Rivera,María
I. INTRODUCCIÓN .................................................................................................... 2
II. DEFINICION ............................................................................................................ 3
III. CARACTERISTICAS ..................................................................................... 4
IV. VENTAJAS ...................................................................................................... 5
V. SINTAXIS DEL LENGUAJE ............................................................................. 5
VI. OPERADORES EN PYTHON ..................................................................... 10
VII. PALABRAS RESERVADAS ...................................................................... 15
VIII. ESTRUCTURAS DE DECISION ................................................................ 23
IX. ESTRUCTURAS DE ITERACION ............................................................. 24
X. ANALIZADOR LEXICO DEL LENGUAJE PYTHON ................................. 26

1
 I. INTRODUCCIÓN

Si trabajas 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. En este
trabajo nuestro objetivo es realizar un analizador léxico funcional para un
lenguaje formal y sencillo como lo es Python, utilizando el lenguaje de
programación java. Teniendo como librería jflex.
La herramienta conocida como Lex, o Flex en una implementación más reciente,
que nos permite especificar un analizador léxico mediante la especificación de
expresiones regulares para describir patrones de los tokens. La notación de
entrada para la herramienta Lex se conoce como el lenguaje Lex. La herramienta
en sí es el compilador Lex. El compilador Lex transforma los patrones de entrada
en un diagrama de transición y genera el código del analizador lexicográfico.
Un analizador léxico es un programa que busca en, generalmente, grandes
ficheros de texto, aquellas cadenas que se corresponden con unos patrones
especificados en el analizador. Se mostrara un reporte de los errores propios del
lenguaje Python, si los hubiera. En el Archivo Flex se incluirá todos los lexemas
que acepta el lenguaje Python. Este archivo Flex consta de tres partes: Las
definiciones básicas, Patrones de acciones, Funciones auxiliares.
Espero sea de su agrado.

2
II. DEFINICION

 Python es un lenguaje de programación poderoso y fácil de aprender.

 Cuenta con estructuras de datos eficientes y de alto nivel y un enfoque
simple pero efectivo a la programación orientada a objetos.
 Tiene desarrollo rápido de aplicaciones en diversas áreas y sobre la
mayoría de las plataformas.
 Tiene la poderosa capacidad de contar con una sintaxis muy limpia y
clara, es decir, altamente legible y comprensible para el ser humano.
Cuenta con módulos, clases, excepciones, tipos de datos de muy alto
nivel. Existen interfaces para hacer llamadas al sistema y librerías, así
como diversos sistemas de ventanas.Es usado como un lenguaje para
extender aplicaciones escritas en algún otro lenguaje, que necesite ser
usado bajo scripting o automatización de la interfaz.

3
III. CARACTERISTICAS

a) PROPÓSITO
Se pueden crear todo tipo de programas. No es un lenguaje creado
específicamente para la web, aunque entre sus posibilidades sí se
encuentra el desarrollo de páginas.
b) MULTIPLATAFORMA
Hay versiones disponibles de Python en muchos sistemas informáticos
distintos. Originalmente se desarrolló para Unix, aunque cualquier sistema
es compatible con el lenguaje siempre y cuando exista un intérprete
programado para él.

c) INTERPRETADO
Quiere decir que no se debe compilar el código antes de su ejecución. En
realidad sí que se realiza una compilación, pero esta se realiza de manera
transparente para el programador. En ciertos casos, cuando se ejecuta
por primera vez un código, se producen unos bytecodes que se guardan
en el sistema y que sirven para acelerar la compilación implícita que
realiza el intérprete cada vez que se ejecuta el mismo código.
d) INTERACTIVO
Python dispone de un intérprete por línea de comandos en el que se
pueden introducir sentencias. Cada sentencia se ejecuta y produce un
resultado visible, que puede ayudarnos a entender mejor el lenguaje y
probar los resultados de la ejecución de porciones de código
rápidamente.
e) ORIENTADO A OBJETOS
La programación orientada a objetos está soportada en Python y ofrece
en muchos casos una manera sencilla de crear programas con
componentes reutilizables.
f) FUNCIONES
Dispone de muchas funciones incorporadas en el propio lenguaje, para el
tratamiento de strings, números, archivos, etc. Además, existen muchas
librerías que podemos importar en los programas para tratar temas
específicos como la programación de ventanas o sistemas en red o cosas
tan interesantes como crear archivos comprimidos en .zip.
g) SINTAXIS
Por último, destacar que Python tiene una sintaxis muy visual, gracias a
una notación identada (con márgenes) de obligado cumplimiento. En
muchos lenguajes, para separar porciones de código, se utilizan
elementos como las llaves o las palabras clave begin y end. Para separar
las porciones de código en Python se debe tabular hacia dentro,
colocando un margen al código que iría dentro de una función o un bucle.

4
IV. VENTAJAS

 La cantidad de librerías que contiene, tipos de datos y funciones

incorporadas en el propio lenguaje, que ayudan a realizar muchas tareas
habituales sin necesidad de tener que programarlas desde cero.
 La sencillez y velocidad con la que se crean los programas. Un programa
en Python puede tener de 3 a 5 líneas de código menos que su
equivalente en Java o C.
 La cantidad de plataformas en las que podemos desarrollar, como Unix,
Windows, OS/2, Mac, Amiga y otros.

V. SINTAXIS DEL LENGUAJE

VARIABLES: Una variable es un espacio para almacenar datos modificables, en

la memoria de un ordenador. En Python, una variable se define con la sintaxis:

Cada variable, tiene un nombre y un valor, el cual define a la vez, el tipo de datos
de la variable.
Utilizar nombres descriptivos y en minúsculas. Para nombres compuestos,
separar las palabras por guiones bajos. Antes y después del signo =, debe haber
uno (y solo un) espacio en blanco

5
CONSTANTES: Son variables que se utiliza para definir valores fijos, que no
requieran ser modificados.
Utilizar nombres descriptivos y en mayúsculas separando palabras por guiones
bajos.

IMPRIMIR VALOR: Para imprimir un valor en pantalla, en Python, se utiliza la

palabra clave print:

TIPOS DE DATOS:
Una variable (o constante) puede contener valores de diversos tipos. Entre ellos:

TIPO DE DATO EJEMPLO

CADENA DE TEXTO (string)

Número entero edad = 35

Número entero octal edad = 043
Número entero hexagonal edad = 0x23
Número real precio = 7435.28
Booleano (Verdadero / verdadero = True
Falso) falso = False

 Flotante: Los números reales son los que tienen decimales. En Python
se expresan mediante el tipo float.

6
 Números Complejos: Los números complejos en Python se representan
de la siguiente forma: complejo = 2.1 + 7.8j

 Cadenas: Las cadenas no son más que texto encerrado entre comillas
simples ('cadena') o dobles ("cadena"). Dentro de las comillas se pueden
añadir caracteres especiales escapándolos con '\', como '\n', el carácter
de nueva línea, o '\t', el de tabulación.
Una cadena puede estar precedida por el carácter 'u' o el carácter 'r', los
cuales indican, respectivamente, que se trata de una cadena que utiliza
codificación Unicode y una cadena raw (del inglés, cruda). Las cadenas
raw se distinguen de las normales en que los caracteres escapados
mediante la barra invertida (\) no se sustituyen por sus contrapartidas.
Esto es especialmente útil, por ejemplo, para las expresiones regulares.
unicode = u"äóè" raw = r"\n"
También es posible encerrar una cadena entre triples comillas (simples o
dobles). De esta forma podremos escribir el texto en varias líneas, y al
imprimir la cadena, se respetarán los saltos de línea que introdujimos sin
tener que recurrir al carácter \n, así como las comillas sin tener que
escaparlas.

 Nombres:
Los nombres pueden empezar con un guion bajo _ o un carácter
alfabético. Después del primer carácter, se pueden utilizar caracteres
alfabéticos, números y/o guiones bajos. No se permiten caracteres
distintos a los alfabéticos o que pudieran confundirse con operadores
como "|", "~", "#", "-", etc. Se pueden utilizar mayúsculas, pero cabe
señalar que Python es sensible a mayúsculas.

7
8
VARIABLES NO INICIALIZADAS EN PYTHON
En Python, la primera operación sobre una variable debe ser la asignación de un
valor. No se puede usar una variable a la que no se ha asignado previamente un
valor.
Como puedes ver, se genera una excepción NameError, es decir, de “error de
nombre”.
El texto explicativo precisa aún más lo sucedido “el nombre a no esta definido”.
La asignación de un valor inicial se denomina inicialización de la variable.
Entonces en Python no es posible usar variables no inicializadas.

9
VI. OPERADORES EN PYTHON
OPERADOR ARITMÉTICO: Entre los operadores aritméticos que Python utiliza,
podemos encontrar los siguientes:

Ejemplo:

COMENTARIOS: UN archivo, no solo puede contener código fuente. También

puede incluir comentarios (notas que como programadores, indicamos en el
código para poder comprenderlo mejor).

10
TIPOS DE DATOS COMPLEJOS:
a) TUPLAS: Una tupla es una variable que permite almacenar varios datos
inmutables (no pueden ser modificados una vez creados) de tipos
diferentes:

Se puede acceder a cada uno de los datos mediante su índice

correspondiente, siendo 0 (cero), el índice del primer elemento:

También se puede acceder a una porción de la tupla, indicando

(opcionalmente) desde el índice de inicio hasta el índice de fin:

Otra forma de acceder a la tupla de forma inversa (de atrás hacia

adelante), es colocando un índice negativo:

b) LISTAS: Una lista es similar a una tupla con la diferencia fundamental de

que permite modificar los datos una vez creados

A las listas se accede igual que a las tuplas, por su número de índice:

Las listas NO son inmutables: permiten modificar los datos una vez
creados:

Las listas, a diferencia de las tuplas, permiten agregar nuevos valores:

c) DICCIONARIOS: Mientras que a las listas y tuplas se accede solo y

únicamente por un número de índice, los diccionarios permiten utilizar una
clave para declarar y acceder a un valor:

11
ELEMENTOS DE UN PROGRAMA
Un programa de Python es un fichero de texto (normalmente guardado con el
juego de caracteres UTF-8) que contiene expresiones y sentencias del lenguaje
Python. Esas expresiones y sentencias se consiguen combinando los elementos
básicos del lenguaje.
El lenguaje Python está formado por elementos (tokens) de diferentes tipos:
 palabras reservadas (keywords)
 funciones integradas (built-in functions)
 literales
 operadores
 delimitadores
 identificadores
En esta lección se comentan los principales elementos del lenguaje. En la
documentación de Python se puede consultar una descripción mucho más
detallada y completa.
Para que un programa se pueda ejecutar, el programa debe ser sintácticamente
correcto, es decir, utilizar los elementos del lenguaje Python respetando sus
reglas de "ensamblaje". Esas reglas se comentan en otras lecciones de este
curso. Obviamente, que un programa se pueda ejecutar no significa que un
programa vaya a realizar la tarea deseada, ni que lo vaya a hacer en todos los
casos.

12
LÍNEAS Y ESPACIOS
Un programa de Python está formado por líneas de texto.

Se recomienda que cada línea contenga una única instrucción, aunque puede
haber varias instrucciones en una línea, separadas por un punto y coma (;).

Por motivos de legibilidad, se recomienda que las líneas no superen los 79

caracteres. Si una instrucción supera esa longitud, se puede dividir en varias
líneas usando el caracter contrabarra (\):

13
Los elementos del lenguaje se separan por espacios en blanco (normalmente,
uno), aunque en algunos casos no se escriben espacios:
 entre los nombres de las funciones y el paréntesis
 antes de una coma (,)
 entre los delimitadores y su contenido (paréntesis, llaves, corchetes o
comillas)
Los espacios no son significativos, es decir, da lo mismo un espacio que varios,
excepto al principio de una línea.
Al ejecutar en IDLE una instrucción con espacios iniciales, se mostraría un aviso
de error de sintaxis:

Al ejecutar un programa, se mostraría una ventana con el mensaje de error de

sintaxis:

El carácter almohadilla (#) marca el inicio de un comentario. Python ignora el

resto de la línea (desde la almohadilla hasta el final de la línea)

14
VII. PALABRAS RESERVADAS
Las palabras reservadas de Python son las que forman el núcleo del lenguaje
Python. Son las siguientes:

Estas palabras no pueden utilizarse para nombrar otros elementos (variables,

funciones, etc.), aunque pueden aparecer en cadenas de texto.
Otras:

15
El intérprete utiliza otros elementos por defecto los cuales aun cuando son parte
fundamental del lenguaje y aun cuando no son palabras reservadas, no se
recomienda utilizarlos como nombres.

El módulo __buitlins__ contiene al resto de estos elementos.

['ArithmeticError',
'AssertionError',
'AttributeError',
'BaseException',
'BlockingIOError',
'BrokenPipeError',
'BufferError',
'BytesWarning',
'ChildProcessError',
'ConnectionAbortedError',
'ConnectionError',
'ConnectionRefusedError',
'ConnectionResetError',
'DeprecationWarning',
'EOFError',
'Ellipsis',
'EnvironmentError',
'Exception',
'False',
'FileExistsError',
'FileNotFoundError',
'FloatingPointError',
'FutureWarning',
'GeneratorExit',
'IOError',
'ImportError',
'ImportWarning',
'IndentationError',
'IndexError',
'InterruptedError',
'IsADirectoryError',
'KeyError',
'KeyboardInterrupt',
'LookupError',
'MemoryError',
'ModuleNotFoundError',
'NameError',
'None',
16
'NotADirectoryError',
'NotImplemented',
'NotImplementedError',
'OSError',
'OverflowError',
'PendingDeprecationWarning',
'PermissionError',
'ProcessLookupError',
'RecursionError',
'ReferenceError',
'ResourceWarning',
'RuntimeError',
'RuntimeWarning',
'StopAsyncIteration',
'StopIteration',
'SyntaxError',
'SyntaxWarning',
'SystemError',
'SystemExit',
'TabError',
'TimeoutError',
'True',
'TypeError',
'UnboundLocalError',
'UnicodeDecodeError',
'UnicodeEncodeError',
'UnicodeError',
'UnicodeTranslateError',
'UnicodeWarning',
'UserWarning',
'ValueError',
'Warning',
'ZeroDivisionError',
'__IPYTHON__',
'__build_class__',
'__debug__',
'__doc__',
'__import__',
'__loader__',
'__name__',
'__package__',
'__spec__',
'abs',
'all',
'any',
'ascii',
'bin',
'bool',
'bytearray',
17
'bytes',
'callable',
'chr',
'classmethod',
'compile',
'complex',
'copyright',
'credits',
'delattr',
'dict',
'dir',
'display',
'divmod',
'enumerate',
'eval',
'exec',
'filter',
'float',
'format',
'frozenset',
'get_ipython',
'getattr',
'globals',
'hasattr',
'hash',
'help',
'hex',
'id',
'input',
'int',
'isinstance',
'issubclass',
'iter',
'len',
'license',
'list',
'locals',
'map',
'max',
'memoryview',
'min',
'next',
'object',
'oct',
'open',
'ord',
'pow',
'print',
'property',
18
'range',
'repr',
'reversed',
'round',
'set',
'setattr',
'slice',
'sorted',
'staticmethod',
'str',
'sum',
'super',
'tuple',
'type',
'vars',
'zip']

19
LITERALES
Los literales son los datos simples que Python es capaz de manejar:
 números: valores lógicos, enteros, decimales y complejos, en notación
decimal, octal o hexadecimal
 cadenas de texto
OPERADORES
Los operadores son los caracteres que definen operaciones matemáticas
(lógicas y aritméticas). Son los siguientes:

DELIMITADORES
Los delimitadores son los caracteres que permiten delimitar, separar o
representar expresiones. Son los siguientes:

20
IDENTIFICADORES
Es un nombre utilizado para identificar una variable, función, clase, módulo u
otro objeto. Un identificador comienza con una letra A a la Z o la A a la Z o un
guión bajo (_) seguido por cero o más letras, pone de relieve, y los dígitos (0 a
9).
Los identificadores están formados por letras (mayúsculas y minúsculas),
números y el carácter guión bajo (_).
Python no permite caracteres de puntuación, como @, $,% y en los
identificadores.
El primer caracter del identificador debe ser una letra
Aquí están siguiendo la convención de nomenclatura para identificador de
Python:
 Los nombres de clases comienzan con una letra mayúscula y todos los
otros identificadores con una letra minúscula.
 A partir de un identificador con un líder de subrayado indica, por
convención, que el identificador está destinado a ser privado.
 A partir de un identificador con dos guiones que conduce indica un
identificador muy privado.
 Si el identificador también se termina con dos detrás de relieve, el
identificador es un lenguaje definido por el nombre especial.

NÚMEROS COMPLEJOS:
Los números imaginarios se escriben con el sufijo " j" o " J". Los números
complejos con una parte real distinta de cero s e escriben "(real+imagj)", y se
pueden crear con la función "complex(real, imag)“.
>>> 1j * 1J
(-1+0j)
>>> 1j * complex(0,1)
(-1+0j)
Para extraer una de las part es de un número complejo z, usa z.real y z.imag.
>>> a=1.5+0.5j
>>> a.real 1.5
>>> a.imag 0.5

21
OPERADOR EXPONENTE:
Este operador sirve para elevar un valor a determinada potencia.
Modo de uso:


Elevar 8 al cuadrado:
8 ** 2
OPERADOR RESTO DE UNA DIVISIÓN:
El operador modulo (%), devuelve el resto de la división entera de dos números.
Es muy común utilizarlo cuando se quiere saber si un número es par o impar.
6 % 2 # == 0
5 % 2 # == 1
Todo los que sigue al signo # es un comentario, 6 % 2 da como resultado 0, el 6
es numero par. Caso contrario con 5, el resto es 1.
OPERADOR DIVISIÓN:
5 / 2 # == 2
Esto se debe a que cuando dividimos dos números enteros el resultado es
entero, para sacar el valor real, al menos un operando debe de ser flotante
5 / 2.0 # == 2.5

22
VIII. ESTRUCTURAS DE DECISION

Varias sentencias de Python permiten al programador especificar que la

siguiente sentencia a ser ejecutada puede ser otra diferente que la siguiente en
secuencia. Esto es llamado transferencia de control. La transferencia de control
se logra con las estructuras de decisión de Python.
If
Las estructuras de decisión escogen entre diferentes cursos de acción. Por
ejemplo, suponga que la nota para aprobar un curso es 60. La sentencia en
pseudocódigo es la siguiente: If student’s grade is greater than or equal to 60.

Si la condición es verdadera, se imprime “Passed”. Si la condición es falsa, la

sentencia de impresión es ignorada. Escrito en Python se vería de la siguiente
manera: If grade >= 60: print “Passed”
If/else y if/elif/else
La estructura de decisión if realiza una acción específica solo cuando la
condición es verdadera; de lo contrario, la acción se ignora. La estructura if/else
permite al programador especificar que una acción diferente se debe desarrollar,
cuando la condición es falsa. Por ejemplo, la sentencia en pseudocódigo: If
student’s grade is greater than or equal to 60

Imprime “Passed” si la nota del estudiante fue superior o igual a 60 e imprime

“Failed” si la nota del estudiante fue menor a 60. Escrito en Python:

23
También se utiliza la estructura de selección múltiple if/elif/else. Que se vería en
Python de la siguiente manera:

IX. ESTRUCTURAS DE ITERACION

WHILE:
Esta estructura permite al programador repetir una acción mientras alguna
condición continúe siendo verdadera. Las sentencias contenidas en la estructura
de repetición del while constituye el cuerpo del ciclo while. Eventualmente la
condición debe cambiar su valor a falso. En este punto la repetición termina.
Ejemplo: X = 1 while x <= 100:

Ejemplo: Name = ‘ ‘ while not name:

print ‘Hello, %sl’ % name

FOR:
Puede ser utilizada para repetir un bloque de código mientras cualquier
condición permanezca verdadera. Una de estas necesidades puede ser utilizar
un bloque de código por cada elemento de un set de valores. Esto se puede
hacer con la estructura for: Ejemplo: words = [‘this’, ’is’, ‘an’, ‘ex’, ‘parrot’] for word
in words: print word or numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] for number in
numbers:

24
FUNCIONES INTEGRADAS

Una función es un bloque de instrucciones agrupadas, que permite reutilizar

partes de un programa. Python incluye las siguientes funciones de forma
predeterminada, es decir, estas funciones siempre están disponibles:

25
X. ANALIZADOR LEXICO DEL LENGUAJE PYTHON

26