• En caso de que exista un error de tipos, lo que ocurre dependerá de si estamos usando un lenguaje interpretado o compilado:

  • Si el lenguaje es interpretado (Python):

    El error se localizará durante la ejecución del programa y el intérprete mostrará un mensaje de error advirtiendo del mismo en el momento justo en que la ejecución alcance la línea de código errónea, para acto seguido finalizar la ejecución del programa.

  • Si el lenguaje es compilado (Java):

    Es muy probable que el comprobador de tipos del compilador detecte el error de tipos durante la compilación del programa, es decir, antes incluso de ejecutarlo. En tal caso, se abortará la compilación para impedir la generación de código objeto erróneo.

• Existen dos mecanismos de conversión de tipos:

  • Conversión implícita o coerción: cuando el intérprete convierte un valor de un tipo a otro sin que el programador lo haya solicitado expresamente.

  • Conversión explícita o casting: cuando el programador solicita expresamente la conversión de un valor de un tipo a otro usando alguna construcción u operación del lenguaje.

• Los lenguajes de tipado fuerte no realizan conversiones implícitas de tipos salvo excepciones muy concretas (por ejemplo, conversiones entre enteros y reales en expresiones aritméticas).

• Los lenguajes de tipado débil se caracterizan, precisamente, por realizar conversiones implícitas cuando, en una expresión, el tipo de un valor no se corresponde con el tipo necesario.

• Ejemplo:

  • Python es un lenguaje fuertemente tipado, por lo que no podemos hacer lo siguiente (da un error de tipos):

    2 + "3"

  • En cambio, PHP es un lenguaje débilmente tipado y la expresión anterior en PHP es perfectamente válida (y vale cinco).

    El motivo es que el sistema de tipos de PHP convierte implícitamente la cadena "3" en el entero 3 cuando se usa en una operación de suma (+).

• Es importante entender que la conversión de tipos no modifica el dato original, sino que devuelve un nuevo dato a partir del dato original pero con el tipo cambiado.

• Recordando lo que dijimos anteriormente, la conversión de tipos no modifica el dato original, sino que devuelve un nuevo dato a partir del dato original pero con el tipo cambiado.

• Las funciones de conversión de tipos hacen precisamente eso: devuelven un nuevo dato con un determinado tipo a partir del dato original que reciben como argumento.

• Por tanto, la expresión int('24') devuelve el entero 24 pero no cambia en modo alguno la cadena '24' que ha recibido como argumento.

• Los enteros y los reales generalmente se pueden combinar en una misma expresión aritmética y suele resultar en un valor real, ya que se considera que los reales contienen a los enteros.

  • Ejemplo: 4 + 3.5 devuelve 7.5.

• Por ello, y aunque el lenguaje sea de tipado fuerte, se permite la conversión implícita entre datos de tipo int y float dentro de una misma expresión para realizar las operaciones correspondientes.

• En el ejemplo anterior, el valor entero 4 se convierte implícitamente en el real 4.0 debido a que el otro operando de la suma es un valor real (3.5). Finalmente, se obtiene un valor real (7.5).

• Concretamente, en una operación aritmética donde puede haber operandos ints y floats, el resultado será:

  • float si al menos uno de los operandos es float, o la operación es la división real (/).

  • int en caso contrario.

• También se puede importar directamente el módulo en sí usando la orden import.

  >>> import math      # importamos el módulo math

• Al importar el módulo, lo que se importan no son sus funciones, sino el propio módulo, el cual es un objeto (de tipo module) al que se accede a través de su nombre y cuyos atributos son (entre otras cosas) las funciones que están definidas dentro del módulo.

• Por eso, para poder llamar a una función del módulo usando esta técnica, debemos indicar el nombre del módulo, seguido de un punto (.) y el nombre de la función:

  >>> import math      # importamos el módulo math
  >>> math.gcd(16, 6)  # la función gcd sigue estando dentro del módulo
  2

  math.gcd(16, 6)
  ─┬── ─┬─
   │    └────── función
   └── módulo

• Eso significa que podríamos ampliar nuestra gramática para permitir que el nombre de una función en una llamada pudiera contener la parte del módulo:

  ⟨llamada_función⟩ ::= ⟨función⟩([⟨lista_argumentos⟩])
  ⟨función⟩ ::= [⟨módulo⟩.]identificador
  ⟨módulo⟩ ::= identificador

• Pero técnicamente no es necesario, ya que las funciones contenidas en un módulo se invocan como si fueran métodos que se ejecutan sobre el objeto módulo, por lo que la sintaxis es la misma que para los métodos y está ya recogida en nuestra gramática:

  ⟨llamada_método⟩ ::= ⟨objeto⟩.⟨método⟩([⟨lista_argumentos⟩])
  ⟨objeto⟩ ::= ⟨expresión⟩
  ⟨método⟩ ::= identificador

• Esto nos dice que hay una relación muy estrecha entre funciones y métodos (de hecho, los métodos son funciones que se invocan de una forma especial).

• De hecho, cuando el objeto es un módulo, no hablamos de métodos sino de funciones (los módulos no contienen métodos).

• No es lo mismo math, que math.gcd, que math.gcd(16, 6):

  • math es un módulo (un objeto de tipo module).

  • math.gcd es una función (no es un método porque math es un módulo).

  • math.gcd(16, 6) es una llamada a función.

  >>> import math
  >>> math
  <module 'math' (built-in)>
  >>> math.gcd
  <built-in function gcd>
  >>> math.gcd(16, 6)
  2

• La lista completa de funciones que incluye el módulo math se puede consultar en su documentación:

  https://docs.python.org/3/library/math.html

• Gracias al módulo operator, podemos reescribir con funciones las expresiones que utilizan operadores.

• Por ejemplo, la expresión:

  >>> 3 * (4 + 5) - 10
  17

  se puede reescribir como:

  >>> from operator import add, mul, sub
  >>> sub(mul(3, add(4, 5)), 10)
  17

• Pasar los operadores de una expresión a funciones es un ejercicio muy interesante que ayuda a entender en qué orden se evalúan las subexpresiones y por qué.

• En Python, en una llamada a función, los argumentos se evalúan siempre antes que la propia llamada (y de izquierda a derecha).

• La expresión 3 * (4 + 5) - 10 se evalúa así:

  3 * (4 + 5) - 10          # se evalúa 3 (devuelve 3)
  = 3 * (4 + 5) - 10        # se evalúa 4 (devuelve 4)
  = 3 * (4 + 5) - 10        # se evalúa 5 (devuelve 5)
  = 3 * (4 + 5) - 10        # se evalúa (4 + 5) (devuelve 9)
  = 3 * 9 - 10              # se evalúa 3 * 9 (devuelve 27)
  = 27 - 10                 # se evalúa 27 - 10 (devuelve 17)
  = 17

• Y la expresión sub(mul(3, add(4, 5)), 10) se evalúa así:

  sub(mul(3, add(4, 5)), 10)    # se evalúa sub (devuelve la función resta)
  = sub(mul(3, add(4, 5)), 10)  # se evalúa mul (devuelve la función multiplicación)
  = sub(mul(3, add(4, 5)), 10)  # se evalúa 3 (devuelve 3)
  = sub(mul(3, add(4, 5)), 10)  # se evalúa add (devuelve la función suma)
  = sub(mul(3, add(4, 5)), 10)  # se evalúa 4 (devuelve 4)
  = sub(mul(3, add(4, 5)), 10)  # se evalúa 5 (devuelve 5)
  = sub(mul(3, add(4, 5)), 10)  # se evalúa add(4, 5) (devuelve 9)
  = sub(mul(3, 9), 10)          # se evalúa mul(3, 9) (devuelve 27)
  = sub(27, 10)                 # se evalúa 10 (devuelve 10)
  = sub(27, 10)                 # se evalúa sub(27, 10) (devuelve 17)
  = 17

• También se pueden escribir literales de tipo cadena encerrándolos entre triples comillas (''' o """).

  Estos literales se usan para escribir cadenas formadas por varias líneas. La sintaxis de las triples comillas respeta los saltos de línea. Por ejemplo:

  >>> """Bienvenido
  ... a
  ... Python"""
  'Bienvenido\na\nPython'  # el carácter \n representa un salto de línea

• No es lo mismo 27 que "27".

  • 27 es un número entero (un literal de tipo int).

  • "27" es una cadena (un literal de tipo str).

• Una cadena vacía es aquella que no contiene ningún carácter. Se representa con los literales '', "", '''''' o """""".

• Si necesitamos meter el carácter de la comilla simple (') o doble (") en un literal de tipo cadena, tenemos dos opciones:

  • Delimitar la cadena con el otro tipo de comillas. Por ejemplo:

    • 'Pepe dijo: "Yo no voy.", así que no fuimos.'

    • "Bienvenido, Señor O'Halloran."

  • «Escapar» la comilla, poniéndole delante una barra inclinada hacia la izquierda (\):

    • "Pepe dijo: \"Yo no voy.\", así que no fuimos."

    • 'Bienvenido, Señor O\'Halloran.'

• Por tanto, max es la función en sí (un valor de tipo función) , y
  max(3, 4) es una llamada a la función max con los argumentos 3 y 4 (una operación realizada sobre la función).

  >>> max                   # la función max
  <built-in function max>
  >>> max(3, 4)             # la llamada a max con los argumentos 3 y 4
  4

• Recordemos que las funciones no tienen expresión canónica, por lo que el intérprete no intentará nunca visualizar un valor de tipo función.

Que traducido a Python sería:

• Por ejemplo, las leyes de DeMorgan, que en Python se escriben así:

  not (a or b) == (not a) and (not b)
  not (a and b) == (not a) or (not b)

  se escribirían así según la notación de la lógica binaria:

  \overline{A + B} = \overline{A} \cdot \overline{B} \overline{AB} = \overline{A} + \overline{B}

• Esta notación se emplea mucho en el diseño de circuitos digitales.

• Por ejemplo, supongamos que queremos demostrar la siguiente propiedad: A(A + B) = A

• Podemos demostrarlo siguiendo la siguiente secuencia de razonamientos:

  \begin{array}{ccl} & A(A + B) \\ = & & \text{\{Ley distributiva\}} \\ & AA + AB \\ = & & \text{\{Ley de idempotencia\}} \\ & A + AB \\ = & & \text{\{Ley de absorción\}} \\ & A \end{array}

• También podemos obtener sus tablas de verdad y comprobar que son idénticas:

  A	B	A + B	A(A + B)
  0	0	0	0
  0	1	1	0
  1	0	1	1
  1	0	1	1

• Como podemos observar, las columnas de A y de A(A + B) son idénticas, lo que significa que toman siempre los mismos valores de verdad y, por tanto, ambas expresiones son equivalentes.

• Su sintaxis es:

  ⟨expr_condicional⟩ ::= ⟨valor_si_cierto⟩ if ⟨condición⟩ else ⟨valor_si_falso⟩

  donde:

  • ⟨condición⟩ debe ser una expresión lógica

  • ⟨valor_si_cierto⟩ y ⟨valor_si_falso⟩ pueden ser expresiones de cualquier tipo

• El valor de la expresión completa será ⟨valor_si_cierto⟩ si la ⟨condición⟩ es cierta; en caso contrario, su valor será ⟨valor_si_falso⟩.

• Ejemplo:

  25 if 3 > 2 else 17

  evalúa a 25.

• El operador ternario, así como los operadores lógicos and y or, se evalúan siguiendo una estrategia según la cual no siempre se evalúan todos sus operandos.

• La expresión condicional:

  ⟨valor_si_cierto⟩ if ⟨condición⟩ else ⟨valor_si_falso⟩

  se evalúa de la siguiente forma:

  • Primero siempre se evalúa la ⟨condición⟩.

  • Si es True, evalúa ⟨valor_si_cierto⟩.

  • Si es False, evalúa ⟨valor_si_falso⟩.

• Por tanto, en la expresión condicional nunca se evalúan todos sus operandos, sino sólo los estrictamente necesarios.

• Además, no se evalúan de izquierda a derecha, como es lo normal.

• La evaluación de los operadores and y or sigue un proceso similar:

  • Primero se evalúa el operando izquierdo.

  • El operando derecho sólo se evalúa si el izquierdo no proporciona la información suficiente para determinar el resultado de la operación.

• Esto es así porque:

  • True or  \;\underline{x}

    siempre es igual a True, valga lo que valga \underline{x}.

  • False and  \;\underline{x}

    siempre es igual a False, valga lo que valga \underline{x}.

  En ambos casos no es necesario evaluar \underline{x}.

• Por ejemplo, tenemos las siguientes expresiones y sus árboles sintácticos equivalentes:

2

2 + 3

2 + 3 * 5

2 * 3 + 5

• Si la expresión contiene llamadas a funciones, se haría:

  max(2, 3 + 5)

  El nodo aplica representa la llamada a la función representada por su primer hijo, pasándole los argumentos representados por el resto de sus hijos.

  Por tanto, tendrá tantos hijos como parámetros tenga la función, más uno (la propia función).

• Para evaluar una expresión representada por su árbol sintáctico, se va recorriendo éste siguiendo un orden que dependerá del lenguaje de programación uilizado.

• En Python se sigue un esquema de recorrido llamado primero en profundidad, donde se van visitando los nodos del árbol de izquierda a derecha y de arriba abajo, buscando siempre el nodo que está más al fondo.

• La idea es que, antes de evaluar un nodo, debemos evaluar primero todos sus nodos hijos, en orden, de izquierda a derecha.

• De esta forma, para evaluar (reducir) un nodo, debemos reducir primero todos sus nodos hijo antes de reducir el propio nodo.

• Si el nodo no tiene hijos, entonces se podrá evaluar directamente.

• La evaluación consiste en ir sustituyendo unos subárboles por otros más reducidos hasta acabar teniendo un árbol que represente la forma normal de la expresión a evaluar.

• Por ejemplo, en la expresión 2 + 3 * 5, representada por este árbol:

• El orden en el que vamos evaluando los nodos sería el siguiente:

2, 3, 5, *, +

• La evaluación se realizaría de la siguiente forma, donde en azul destacamos los nodos que ya están evaluados:

• Paso 1: Se empieza visitando la raíz + pero, como tiene hijos, antes de evaluarlo se pasa a visitar su primer hijo (2).

• Paso 2: Como estamos en el nodo 2 y éste no tiene hijos, se puede evaluar directamente, ya que es un nodo hoja y, por tanto, representa un valor. La evaluación del nodo no cambia el nodo ni lo sustituye por ningún otro.

• Paso 3: Volvemos al padre del nodo 2, que es el nodo raíz +, el cual todavía no lo podemos evaluar porque aún le queda otro nodo hijo por evaluar (el nodo *), así que bajamos hasta él. Éste, a su vez, tampoco se puede evaluar porque tiene hijos que hay que evaluar antes, el primero de los cuales es el nodo 3, así que evaluamos 3, que se evalúa directamente ya que es un nodo hoja.

• Paso 4: Volvemos al padre del nodo 3, que es el nodo *, el cual todavía no lo podemos evaluar porque aún le queda otro nodo hijo por evaluar (el nodo 5), así que bajamos hasta éste, el cual se evalúa directamente ya que es un nodo hoja.

• Paso 5: Volvemos al padre del nodo 5, que es el nodo *, el cual ya se puede evaluar porque ya se han evaluado todos sus hijos, así que se realiza la operación 3 * 5, dando como resultado 15, por lo que el subárbol que cuelga del nodo * se reduce y se sustituye por un único nodo hoja 15.

• Paso 6: Volvemos al padre del que ahora es el nodo 15, que es el nodo +, el cual ya se puede evaluar porque ya se han evaluado todos sus hijos, así que se realiza la operación 2 + 15, dando como resultado 17, por lo que el subárbol que cuelga del nodo + se reduce y se sustituye por un único nodo hoja 17.

• Como ya se ha reducido el nodo raíz, la evaluación de la expresión ha terminado, dando como resultado un árbol que representa a la forma normal de la expresión inicial.

• Eso quiere decir que el parámetro \underline{x} de la función abs admite un valor de cualquier tipo numérico, ya sea un entero o un real.

• Por tanto, Number es un tipo que representa a varios tipos a la vez.

• Cuando eso ocurre, decimos que ese tipo es polimórfico.

  Por eso podemos afirmar que Number es un tipo polimórfico en Python.

• De la misma forma (aunque se utiliza menos), podemos decir que un valor polimórfico es un valor que pertenece a un tipo polimórfico.

• Asimismo, una operación polimórfica es aquella en cuya signatura aparece algún tipo polimórfico.

  Por ejemplo, la función abs definida con un parámetro de tipo Number sería polimórfica, ya que ese parámetro tendría un tipo polimórfico.

• Es decir, es como si el operador + representara dos operaciones distintas con dos signaturas distintas:

  +(a: Number, b: Number) -> Number

  +(a: str, b: str) -> str

  de forma que, al usar el operador en una expresión del tipo:

  ⟨expr⟩_1 + ⟨expr⟩_2

  el intérprete llamará a una de las dos operaciones, dependiendo de los tipos de ⟨expr⟩_1 y ⟨expr⟩_2.

• La sobrecarga no es polimorfismo, pero induce un cierto tipo de polimorfismo que se denomina polimorfismo ad-hoc.

• Esto es así porque tener varias operaciones diferentes con el mismo nombre pero con distinta signatura, equivale a tener una sola operación polimórfica donde algunos operandos pueden tomar un valor de varios tipos.

  Por ejemplo, los tipos de a y b representarían a la vez a Number y str.

• De hecho, en Python hay operaciones que tienen las tres formas. Por ejemplo, ya vimos anteriormente la operación potencia, que consiste en elevar un número a la potencia de otro (x^y). Esta operación se puede hacer:

  • Con el operador **:

    >>> 2 ** 4
    16

  • Con la función pow:

    >>> pow(2, 4)
    16

  • Con el método __pow__:

    >>> (2).__pow__(4)
    16

• La forma más general de representar una operación es la función, ya que cualquier operación se puede expresar en forma de función (cosa que no ocurre con los operadores y los métodos).

• Los operadores y los métodos son formas sintácticas especiales para representar operaciones que se podrían representar igualmente mediante funciones.

• Por eso, al hablar de operaciones, y mientras no se diga lo contrario, podremos suponer que están representadas como funciones.

• Eso implica que los conceptos de conjunto origen, conjunto imagen, dominio, rango, aridad, argumento, resultado, composición y asociación (o correspondencia), que estudiamos cuando hablamos de las funciones, también existen en los operadores y los métodos.

• Es decir: todos esos son conceptos propios de cualquier operación, da igual la forma que tenga esta.

• Muchos lenguajes de programación no permiten definir nuevos operadores, pero sí permiten definir nuevas funciones (o métodos, dependiendo del paradigma utilizado).

• En algunos lenguajes, los operadores son casos particulares de funciones (o métodos) y se pueden definir como tales. Por tanto, en estos lenguajes se pueden crear nuevos operadores definiendo nuevas funciones (o métodos).