• Además, una función no puede producir ningún efecto observable fuera de ella (los llamados efectos laterales), salvo calcular y devolver su resultado.

• Esto quiere decir que en programación funcional no existen los efectos laterales, o se dan de forma muy localizada en partes muy concretas e imprescindibles del programa.

• Por todo lo expuesto anteriormente, se dice que las funciones en programación funcional son funciones puras, es decir, funciones que lo único que hacen es calcular su resultado (sin ningún otro efecto) y en las que ese resultado sólo depende de los datos de entrada.

• Además, los valores nunca cambian porque no tienen estado interno que se pueda alterar con el tiempo.

• Como consecuencia de todo lo anterior, en programación funcional es posible sustituir cualquier expresión por su valor, propiedad que se denomina transparencia referencial.

• En programación funcional, las funciones también son valores, por lo que se consideran a éstas como ciudadanas de primera clase.

• Un programa funcional está formado únicamente por definiciones de valores y por expresiones que hacen uso de los valores definidos.

• Por tanto, en programación funcional, ejecutar un programa equivale a evaluar una expresión.

• Para describir el proceso llevado a cabo por el programa no es necesario bajar al nivel de la máquina, sino que basta con interpretarlo como un sistema de evaluación de expresiones.

• Esa evaluación de expresiones se lleva a cabo mediante reescrituras que usan las definiciones para tratar de alcanzar la forma normal de la expresión.

• En consecuencia, un requisito para conseguir la transparencia referencial es que las expresiones no cambien de valor dependiendo de cuándo se evalúen.

• Es decir: una expresión en programación funcional siempre debe tener el mismo valor.

• Por tanto, en programación funcional no se permite que la misma expresión, evaluada en dos momentos diferentes, devuelva como resultado dos valores diferentes.

• Asimismo, el valor de una expresión tampoco debe depender del orden en el que se evalúen sus subexpresiones.

• Uno de los requisitos para alcanzar la transparencia referencial es que no existan efectos laterales.

• Por tanto, en programación funcional no están permitidos los efectos laterales.

• Eso significa que:

  • Al evaluar una expresión no se pueden provocar efectos laterales.

    Si esto ocurriera, no podríamos sustituir una expresión por su valor.

  • El valor de una expresión no puede depender de un efecto lateral ni verse afectado por la existencia de efectos laterales.

    Si esto ocurriera, la expresión podría tener valores distintos en momentos distintos.

• En cualquiera de los dos casos, se rompería la transparencia referencial.

• Definición:

  Modelo de ejecución:

  Es una herramienta conceptual que permite a los programadores razonar sobre el funcionamiento de un programa sin tener que ejecutarlo directamente en el ordenador.

• Podemos definir diferentes modelos de ejecución dependiendo, principalmente, de:

  • El paradigma de programación utilizado (ésto sobre todo).

  • El lenguaje de programación con el que escribamos el programa.

  • Los aspectos que queramos estudiar de nuestro programa.

• La ventaja del modelo de sustitución es que no necesitamos recurrir a pensar que debajo de todo esto hay un ordenador con una determinada arquitectura hardware, que almacena los datos en celdas de la memoria principal, que ejecuta ciclos de instrucción en la CPU, que las instrucciones modifican los datos de la memoria…

• Todo resulta mucho más fácil que eso, ya que todo se reduce a evaluar expresiones, reescribiendo unas subexpresiones por otras, sin importar aspectos secundarios como la tecnología, el momento en el que se evalúan, el orden en el que se evalúan, etc.

• Y la evaluación de expresiones no requiere pensar que hay un ordenador que lleva a cabo el proceso de evaluación.

• Esto se debe a que la programación funcional se basa en el cálculo lambda, que es un modelo teórico matemático.

• Ya estudiamos que evaluar una expresión consiste en encontrar su forma normal.

• En programación funcional:

  • Los intérpretes alcanzan este objetivo a través de múltiples pasos de reducción de las expresiones para obtener otra equivalente más simple.

  • Toda expresión posee un valor definido, y ese valor no depende del orden ni el momento en el que se evalúe.

  • El significado de una expresión es su valor, y no puede ocurrir ningún otro efecto, ya sea oculto o no, en ninguna operación que se utilice para calcularlo.

• En general, las operaciones se definen de forma que sólo pueden actuar sobre valores de determinados tipos.

  O dicho de otra forma: esas son las operaciones que tiene sentido realizar sobre esos valores.

  Esto es así porque recordemos que las operaciones actúan como funciones que están definidas sobre un dominio, que es un subconjunto del conjunto origen. Ese conjunto origen sería, a grandes rasgos, el tipo de los valores sobre los que puede actuar.

  Por ejemplo: sobre un valor de tipo cadena se puede realizar la operación longitud (pero no la raíz cuadrada), y sobre dos enteros se pueden realizar las operaciones de suma y producto.

• En resumen, podemos decir que un tipo:

  • Es un conjunto de valores.

  • Que, indirectamente, define también el conjunto de operaciones válidas que se pueden realizar sobre dichos valores.

• Como los datos tienen (o representan) valores, las operaciones también pueden actuar sobre datos.

  En realidad, lo que hacen las operaciones es actuar sobre los valores que tienen esos datos.

• Por tanto, también se puede decir que las operaciones que se pueden realizar sobre un dato dependen del tipo de ese dato.

• Y, por extensión, podemos decir que un tipo de datos:

  • Es el conjunto de valores que puede tomar un dato de ese tipo.

  • Que, indirectamente, define también el conjunto de operaciones válidas que se pueden realizar sobre datos de ese tipo.

• Definiciónes ampliadas:

  Tipo (o tipo de datos):

  Es un conjunto de valores que, indirectamente, define también el conjunto de operaciones que se pueden realizar sobre esos valores.

  Tipo de un dato:

  Es el tipo que tiene ese dato, es decir, una característica o atributo del dato que define el conjunto de valores que puede tomar ese dato y, en consecuencia, también las operaciones que se pueden realizar sobre ese dato.

• Igualmente, por extensión podemos definir también el tipo de una expresión como el tipo al que pertenece el valor de la expresión:

  Tipo de una expresión:

  Es el tipo del valor resultante de evaluar dicha expresión.

• Los tipos de un lenguaje de programación tienen un nombre (un identificador) que los representa.

• Ejemplos en Python:

  • El tipo int define el conjunto de los números enteros, sobre los que se pueden realizar, entre otras, las operaciones aritméticas.

    Se corresponde más o menos con el símbolo matemático \mathbb{Z}, que ya hemos usado antes y que representa el conjunto de los números enteros en Matemáticas.

  • El tipo float define el conjunto de los números reales, sobre los que se pueden realizar también operaciones aritméticas.

    Se corresponde más o menos con el símbolo matemático \mathbb{R}, que representa el conjunto de los números reales en Matemáticas.

  • El tipo str define el conjunto de las cadenas, sobre las que se pueden realizar otras operaciones (concatenación, repetición, etc.).

¿Por qué decimos «más o menos»?

• 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.

• 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).

• 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.'

• Al igual que ocurre con las cadenas, tenemos las operaciones t[0], t[1:] y + (concatenación).

• Con la concatenación se pueden crear nuevas tuplas a partir de otras tuplas.

• Por ejemplo:

  >>> (1, 2, 3) + (4, 5, 6)
  (1, 2, 3, 4, 5, 6)

• Eso significa que, si t es una tupla no vacía, se cumple que
  t == (t[0],) + t[1:].

  Esta propiedad es similar (aunque no exactamente igual) a la que se cumple en las cadenas no vacías.

• 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.

• 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

• El lenguaje Python es, principalmente, un lenguaje orientado a objetos.

• De hecho, todos los datos en Python son objetos que tienen sus propios atributos (métodos, entre otros) a los que se le puede acceder usando el operador punto (.).

• Por ello, en Python los términos «dato», «valor» y «objeto» son sinónimos en la práctica.

• Los números, las cadenas, los módulos, las funciones… todos son objetos.

• Incluso los métodos son objetos, ya que, en realidad, son funciones contenidas dentro de otros objetos, y las funciones son objetos.

• Hasta los tipos (como int o str) son objetos que tienen sus propios atributos.

• Entraremos a estudiar más en detalle estas características cuando veamos la programación orientada a objetos.

• 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

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 principalmente 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).