Menú Cerrar
Calculadora en python

En esta entrada vamos a implementar una calculadora en python usando expresiones regulares. El contenido que vamos a ver es el siguiente:

Expresión regular

En computación, una expresión regular es una secuencia de caracteres que conforma un patrón de búsqueda. Se utilizan principalmente para la búsqueda de patrones de cadenas de caracteres u operaciones de sustituciones.

Las expresiones regulares son patrones utilizados para encontrar una determinada combinación de caracteres dentro de una cadena de texto. Las expresiones regulares proporcionan una manera muy flexible de buscar o reconocer cadenas de texto.

En otras palabras: una expresión regular es una forma de representar los lenguajes regulares (finitos o infinitos) y se construye utilizando caracteres del alfabeto sobre el cual se define el lenguaje.

Implementación de la calculadora en python

Para usar expresiones regulares, es necesario definir las palabras claves o tokens de nuestro vocabulario. En el código se definen los tokens en la primera parte y sus equivalentes. Posteriormente se define la función para cada uno.

Ahora vamos a ver el código completo de la calculadora.

import math

tokens = (

    'NAME','NUMBER','FLOAT',
    'PLUS','MINUS','TIMES','DIVIDE','EQUALS',
    'LPAREN','RPAREN','COS','SEN','TAN','SEC','CSC','COT','COSH','SENH','TANH','SECH','CSCH','COTH','IMG',
    )

# Tokens

t_PLUS    = r'\+'
t_MINUS   = r'-'
t_TIMES   = r'\*'
t_DIVIDE  = r'/'
t_EQUALS  = r'='
t_LPAREN  = r'\('
t_RPAREN  = r'\)'
t_NAME    = r'(?!j|cos|sen|tan|csc|sec|cot|cosh|senh|tanh|sech|csch|coth)([a-zA-Z_][a-zA-Z0-9_]*)'
t_COS     = r'cos'
t_SEN     = r'sen'
t_TAN     = r'tan'
t_SEC     = r'sec'
t_CSC     = r'csc'
t_COT     = r'cot'
t_COSH    = r'cosh'
t_SENH    = r'senh'
t_TANH    = r'tanh'
t_SECH    = r'sech'
t_CSCH    = r'csch'
t_COTH    = r'coth'
t_IMG     = r'j'

def t_FLOAT(t):
    r'\d+\.\d+'
    t.value = float(t.value)
    return t

def t_NUMBER(t):
    r'\d+'
    try:
        t.value = int(t.value)
    except ValueError:
        print("Integer value too large %d", t.value)
        t.value = 0
    return t

# Ignorar caracteres
t_ignore = " \t"

def t_newline(t):
    r'\n+'
    t.lexer.lineno += t.value.count("\n")

def t_error(t):
    print("Illegal character '%s'" % t.value[0])
    t.lexer.skip(1)

# Lexer
import ply.lex as lex
lexer = lex.lex()

# Reglas de parsing

precedence = (
    ('left','PLUS','MINUS'),
    ('left','TIMES','DIVIDE','COS','SEN','TAN','SEC','CSC','COT','COSH','SENH','TANH','SECH','CSCH','COTH'),
    ('right','UMINUS','IMG'),
    )

# diccionario de nombres
names = { }

def p_statement_assign(t):
    'statement : NAME EQUALS expression'
    names[t[1]] = t[3]

def p_statement_expr(t):
    'statement : expression'
    print(t[1])

def p_expression_binop(t):
    '''expression : expression PLUS expression
                  | expression MINUS expression
                  | expression TIMES expression
                  | expression DIVIDE expression'''
    if t[2] == '+'  : t[0] = t[1] + t[3]
    elif t[2] == '-': t[0] = t[1] - t[3]
    elif t[2] == '*': t[0] = t[1] * t[3]
    elif t[2] == '/': t[0] = t[1] / t[3]

def p_expression_compsim(t):
    'expression : expression IMG'
    t[0] = complex(0,t[1])

def p_expression_cos(t):
    'expression : COS expression'
    t[0] = math.cos(t[2])
def p_expression_sen(t):
    'expression : SEN expression'
    t[0] = math.sin(t[2])
def p_expression_tan(t):
    'expression : TAN expression'
    t[0] = math.tan(t[2])
def p_expression_sec(t):
    'expression : SEC expression'
    t[0] = 1/math.cos(t[2])
def p_expression_csc(t):
    'expression : CSC expression'
    t[0] = 1/math.sin(t[2])
def p_expression_cot(t):
    'expression : COT expression'
    t[0] = 1/math.tan(t[2])

def p_expression_cosh(t):
    'expression : COSH expression'
    t[0] = math.cosh(t[2])
def p_expression_senh(t):
    'expression : SENH expression'
    t[0] = math.sinh(t[2])
def p_expression_tanh(t):
    'expression : TANH expression'
    t[0] = math.tanh(t[2])
def p_expression_sech(t):
    'expression : SECH expression'
    t[0] = 1/math.cosh(t[2])
def p_expression_csch(t):
    'expression : CSCH expression'
    t[0] = 1/math.sinh(t[2])
def p_expression_coth(t):
    'expression : COTH expression'
    t[0] = 1/math.tanh(t[2])

def p_expression_uminus(t):
    'expression : MINUS expression %prec UMINUS'
    t[0] = -t[2]

def p_expression_group(t):
    'expression : LPAREN expression RPAREN'
    t[0] = t[2]

def p_expression_number(t):
    'expression : NUMBER'
    t[0] = t[1]

def p_expression_float(t):
    'expression : FLOAT'
    t[0] = t[1]

def p_expression_name(t):
    'expression : NAME'
    try:
        t[0] = names[t[1]]
    except LookupError:
        print("Nombre no definido '%s'" % t[1])
        t[0] = 0

def p_error(t):
    print("Error de sintaxis en '%s'" % t.value)

import ply.yacc as yacc
parser = yacc.yacc()

while True:
    try:
        s = input('calculadora > ')   # Usa raw_input in Python 2
    except EOFError:
        break
    parser.parse(s)

En python copiar y pegar código es una pesadilla para los programadores ya que si no está bien estructurado, marca error o hace otra cosa. Pensamos en eso y por eso, descarga el código haciendo click aquí. ¡No olvides mostrar tu apoyo dejando un “Me gusta”!

Acerca del autor

Saintus Zephir

Ingeniero en Sistemas Computacionales y estudiante de Maestría en Ciencias en Ingeniería y Tecnologías Computacionales en el Centro de Investigación y de Estudios Avanzados del IPN (CINVESTAV-IPN).

Comparte el artículo en tus redes sociales

Artículos relacionados

11 comentarios

  1. Cynthia

    You really make it appear really easy together with your presentation however
    I in finding this matter to be really one thing which
    I believe I’d never understand. It kind of feels
    too complex and extremely vast for me. I’m taking a look forward to your next publish, I’ll try to get the dangle of it!

  2. Lowell

    For newest information you have to go to see world-wide-web and
    on the web I found this site as a most excellent web site for most recent updates.

  3. Benjamin

    What’s up to every one, the contents present at this website are really awesome
    for people knowledge, well, keep up the good work fellows.

  4. Ramona

    Hey there! I know this is somewhat off topic but I was wondering which blog platform are you using for this website?
    I’m getting tired of WordPress because I’ve had problems with hackers and I’m
    looking at alternatives for another platform.
    I would be fantastic if you could point me in the direction of a good platform.

  5. Woodrow

    I’d like to find out more? I’d care to find out some additional information.

  6. Chasity

    Quality content is the main to interest the people to pay a visit the
    web site, that’s what this website is providing.

  7. Tasha

    I think this is one of the most significant info for me.
    And i’m glad reading your article. But want to remark on some general things, The
    website style is perfect, the articles is really excellent
    : D. Good job, cheers

Deja una respuesta

Tu dirección de correo electrónico no será publicada.

× ¿Cómo puedo ayudarte?