1 Introducción

1.1 Concepto

• La programación funcional es un paradigma de programación declarativa basado en el uso de definiciones, expresiones y funciones matemáticas.

• Tiene su origen teórico en el cálculo lambda, un sistema matemático creado en 1930 por Alonzo Church.

• Los lenguajes funcionales se pueden considerar azúcar sintáctico (es decir, una forma equivalente pero sintácticamente más sencilla) del cálculo lambda.

• En programación funcional, una función define un cálculo a realizar a partir de unos datos de entrada, con la propiedad de que el resultado de la función sólo puede depender de esos datos de entrada.

• Eso significa que una función no puede tener estado interno ni su resultado puede depender del estado del programa.

1.2 Transparencia referencial

• En programación funcional, el valor de una expresión depende, exclusivamente, de los valores de las subexpresiones que la forman.

• Dichas subexpresiones, además, pueden ser sustituidas libremente por otras que tengan el mismo valor.

• A esta propiedad se la denomina transparencia referencial.

• Formalmente, se puede definir así:

  Transparencia referencial:

  Si p = q, entonces f(p) = f(q).

• En la práctica, eso significa que la evaluación de una expresión no puede provocar efectos laterales y que su valor no puede depender del momento en el que se evalúe la expresión (la expresión siempre va a valer lo mismo).

1.2.1 Efectos laterales

• Los efectos laterales son aquellos que provocan un cambio de estado irremediable en el sistema, que además son observables fuera del contexto donde se producen y que puede dar lugar a que una misma expresión tenga dos valores según el momento en el que se evalúe.

• Por ejemplo, las instrucciones de E/S (entrada y salida) provocan efectos laterales, ya que:

  • Al leer un dato de la entrada (ya sea el teclado, un archivo del disco, una base de datos…) estamos afectando al estado del dispositivo de entrada, y además no se sabe de antemano qué valor se va a recibir, ya que éste proviene del exterior y no lo controlamos.

  • Al escribir un dato en la salida (ya sea la pantalla, un archivo, una base de datos…) estamos realizando un cambio que afecta irremediablemente al estado del dispositivo de salida.

• En posteriores temas veremos que existe un paradigma (el paradigma imperativo) que se basa principalmente en provocar efectos laterales.

1.3 Modelo de ejecución

• Cuando escribimos programas (y algoritmos) nos interesa abstraernos del funcionamiento detallado de la máquina que va a ejecutar esos programas.

• Nos interesa buscar una metáfora, un símil de lo que significa ejecutar el programa.

• De la misma forma que un arquitecto crea modelos de los edificios que se pretenden construir, los programadores podemos usar modelos que simulan en esencia el comportamiento de nuestros programas.

• Esos modelos se denominan modelos computacionales o modelos de ejecución.

• Los modelos de ejecución nos permiten razonar sobre los programas sin tener que ejecutarlos.

1.3.1 Modelo de sustitución

• En programación funcional, un programa es una expresión y lo que hacemos al ejecutarlo es evaluar dicha expresión, usando para ello las definiciones de operadores y funciones predefinidas por el lenguaje, así como las definidas por el programador en el código fuente del programa.

• Recordemos que la evaluación de una expresión, en esencia, es el proceso de sustituir, dentro de ella, unas subexpresiones por otras que, de alguna manera bien definida, estén más cerca del valor a calcular, y así hasta calcular el valor de la expresión al completo.

• Por ello, la ejecución de un programa funcional se puede modelar como un sistema de reescritura al que llamaremos modelo de sustitución.

• El modelo de sustitución es un buen modelo de ejecución para la programación funcional gracias a que se cumple la transparencia referencial.

2 Tipos de datos

2.1 Concepto

• Los valores que comparten características y propiedades comunes se agrupan en conjuntos llamados tipos de datos o, simplemente, tipos.

• Por tanto, un tipo (o tipo de datos) es un conjunto de valores:

  Tipo (de datos):

  Es un conjunto de valores.

• Se dice que «un valor pertenece a un tipo» cuando pertenece a ese conjunto (es decir, cuando es uno de los elementos de ese conjunto).

  Por ejemplo, el tipo entero representa el conjunto de los números enteros. Los diferentes números enteros pertenecen al tipo entero.

2.2 Tipo de un dato

• Recordemos que un dato puede tomar valores.

• Por extensión, el tipo de un dato es el conjunto de los posibles valores que puede tomar ese dato.

  En cierta forma, el tipo de un dato es como una etiqueta, característica o atributo que va asociado al dato y que define una cualidad muy importante del mismo.

  Se dice que «un dato es de un tipo», o que «un dato tiene un tipo» o que «un dato pertenece a un tipo» cuando ese dato tiene (o puede tener) un valor de ese tipo.

• Dependiendo del lenguaje de programación utilizado, el tipo de un dato puede venir definido:

  • Implícitamente, como el tipo del valor que tiene actualmente el dato.

  • Explícitamente, asociando el tipo al dato mediante una instrucción especial llamada declaración.

2.3 type

• La función type devuelve el tipo de un valor:

  >>> type(3)
  <class 'int'>
  >>> type(3.0)
  <class 'float'>
  >>> type('hola')
  <class 'str'>

• Es muy útil para saber el tipo de una expresión compleja:

  >>> type(3 + 4.5 ** 2)
  <class 'float'>

2.4 Sistema de tipos

• El sistema de tipos de un lenguaje es el conjunto de reglas que asigna un tipo a cada elemento del programa.

• Exceptuando a los lenguajes no tipados (Ensamblador, código máquina, Forth…) todos los lenguajes tienen su propio sistema de tipos, con sus características.

• El sistema de tipos de un lenguaje depende también del paradigma de programación que soporte el lenguaje. Por ejemplo, en los lenguajes orientados a objetos, el sistema de tipos se construye a partir de los conceptos propios de la orientación a objetos (clases, interfaces…).

2.4.1 Errores de tipos

• Cuando se intenta realizar una operación sobre un dato cuyo tipo no admite esa operación, se produce un error de tipos.

• Ese error puede ocurrir cuando:

  • Los operandos de un operador no pertenecen al tipo que el operador necesita (ese operador no está definido sobre datos de ese tipo).

  • Los argumentos de una función o método no son del tipo esperado.

• Por ejemplo:

  4 + "hola"

  es incorrecto porque el operador + no está definido sobre un entero y una cadena (no se pueden sumar un número y una cadena).

2.4.2 Tipado fuerte vs. débil

• Un lenguaje de programación es fuertemente tipado (o de tipado fuerte) si no se permiten violaciones de los tipos de datos.

• Es decir, un valor de un tipo concreto no se puede usar como si fuera de otro tipo distinto a menos que se haga una conversión explícita.

• Un lenguaje es débilmente tipado (o de tipado débil) si no es de tipado fuerte.

• En los lenguajes de tipado débil se pueden hacer operaciones entre datos cuyo tipos no son los que espera la operación, gracias al mecanismo de conversión implícita.

2.5 Tipos de datos básicos

• Los tipos de datos básicos que empezaremos a estudiar en Python son:

\text{Tipos básicos}\begin{cases} \text{Números}\begin{cases} \text{Enteros} \\ \text{Reales} \end{cases} \\ \text{Cadenas} \\ \text{Funciones} \\ \text{Lógicos (o \textit{booleanos})} \end{cases}

2.5.1 Números

• Hay dos tipos numéricos básicos en Python: los enteros y los reales.

  • Los enteros se representan con el tipo int.

    Sólo contienen parte entera, y sus literales se escriben con dígitos sin punto decimal (ej: 13).

  • Los reales se representan con el tipo float.

    Contienen parte entera y parte fraccionaria, y sus literales se escriben con dígitos y con punto decimal separando ambas partes (ej: 4.87). Los números en notación exponencial (2e3) también son reales (2e3 = 2.0\times10^3).

• Las operaciones que se pueden realizar con los números son los que cabría esperar (aritméticas, trigonométricas, matemáticas en general).

2.5.2 Cadenas

• Las cadenas son secuencias de cero o más caracteres codificados en Unicode.

• En Python se representan con el tipo str.

  • No existe el tipo carácter en Python. Un carácter en Python es simplemente una cadena que contiene un solo carácter.

• Un literal de tipo cadena se escribe encerrando sus caracteres entre comillas simples (') o dobles (").

  • No hay ninguna diferencia entre usar unas comillas u otras, pero si una cadena comienza con comillas simples, debe acabar también con comillas simples (y viceversa).

• Ejemplos:

  "hola"

  'Manolo'

  "27"

2.5.3 Funciones

• En programación funcional, las funciones también son datos:

  >>> type(max)
  <class 'builtin_function_or_method'>

• La única operación que se puede realizar sobre una función es llamarla, que sintácticamente se representa poniendo paréntesis ( ) justo a continuación de la función.

  Dentro de los paréntesis se ponen los argumentos que se aplican a la función en esa llamada (si es que los necesita), separados por comas.

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

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

2.6 Conversión de tipos

• Hemos visto que en Python las conversiones de tipos deben ser explícitas, es decir, que debemos indicar en todo momento qué dato queremos convertir a qué tipo.

• Para ello existen funciones cuyo nombre coincide con el tipo al que queremos convertir el dato: str, int y float, entre otras.

  >>> 4 + '24'
  Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  TypeError: unsupported operand type(s) for +: 'int' and 'str'
  >>> 4 + int('24')
  28

• Convertir un dato a cadena suele funcionar siempre, pero convertir una cadena a otro tipo de dato puede fallar dependiendo del contenido de la cadena:

  >>> int('hola')
  Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  ValueError: invalid literal for int() with base 10: 'hola'

3 Álgebra de Boole

3.1 El tipo de dato booleano

• Un dato lógico o booleano es aquel que puede tomar uno de dos posibles valores, que se denotan normalmente como verdadero y falso.

• Esos dos valores tratan de representar los dos valores de verdad de la lógica y el álgebra booleana.

• Su nombre proviene de George Boole, matemático que definió por primera vez un sistema algebraico para la lógica a mediados del S. XIX.

• En Python, el tipo de dato lógico se representa como bool y sus posibles valores son False y True.

• Esos dos valores son formas especiales para los enteros 0 y 1, respectivamente.

3.2 Operadores relacionales

• Los operadores relacionales son operadores que toman dos operandos (que usualmente deben ser del mismo tipo) y devuelven un valor booleano.

• Los más conocidos son los operadores de comparación, que sirven para comprobar si un dato es menor, mayor o igual que otro, según un orden preestablecido.

• Los operadores de comparación que existen en Python son:

  < > <= >= == !=

• Por ejemplo:

>>> 4 == 3
False
>>> 5 == 5
True
>>> 3 < 9
True

>>> 9 != 7
True
>>> False == True
False
>>> 8 <= 8
True

3.3 Operadores lógicos

• Las operaciones lógicas se representan mediante operadores lógicos, que son aquellos que toman uno o dos operandos booleanos y devuelven un valor booleano.

• Las operaciones básicas del álgebra de Boole se llaman suma, producto y complemento.

• En lógica proposicional (un tipo de lógica matemática que tiene estructura de álgebra de Boole), se llaman:

  Operación	Operador
  Disyunción	\lor
  Conjunción	\land
  Negación	\neg

• En Python se representan como or, and y not, respectivamente.

3.3.1 Tablas de verdad

• Una tabla de verdad es una tabla que muestra el valor lógico de una expresión compuesta, para cada uno de los valores lógicos que puedan tomar sus componentes.

• Se usan para definir el significado de las operaciones lógicas y también para verificar que se cumplen determinadas propiedades.

• Las tablas de verdad de los operadores lógicos son:

3.4 Axiomas

1. Ley asociativa: \begin{cases} \forall a,b,c \in \mathbb{B}: (a \lor b) \lor c = a \lor (b \lor c) \\ \forall a,b,c \in \mathbb{B}: (a \land b) \land c = a \land (b \land c) \end{cases}

2. Ley conmutativa: \begin{cases} \forall a,b \in \mathbb{B}: a \lor b = b \lor a \\ \forall a,b \in \mathbb{B}: a \land b = b \land a \end{cases}

3. Ley distributiva: \begin{cases} \forall a,b,c \in \mathbb{B}: a \lor (b \land c) = (a \lor b) \land (a \lor c) \\ \forall a,b,c \in \mathbb{B}: a \land (b \lor c) = (a \land b) \lor (a \land c) \end{cases}

4. Elemento neutro: \begin{cases} \forall a \in \mathbb{B}: a \lor F = a \\ \forall a \in \mathbb{B}: a \land V = a \end{cases}

5. Elemento complementario: \begin{cases} \forall a \in \mathbb{B}; \exists \lnot a \in \mathbb{B}: a \lor \lnot a = V \\ \forall a \in \mathbb{B}; \exists \lnot a \in \mathbb{B}: a \land \lnot a = F \end{cases}

Si (\mathbb{B},\lnot,\lor,\land) cumple lo anterior, entonces es un álgebra de Boole.

3.4.0.1 Traducción a Python

3.5 Teoremas fundamentales

6. Ley de idempotencia: \begin{cases} \forall a \in \mathbb{B}: a \lor a = a \\ \forall a \in \mathbb{B}: a \land a = a \end{cases}

7. Ley del elemento absorbente: \begin{cases} \forall a \in \mathbb{B}: a \lor V = V \\ \forall a \in \mathbb{B}: a \land F = F \end{cases}

8. Ley de identidad: \begin{cases} \forall a \in \mathbb{B}: a \lor F = a \\ \forall a \in \mathbb{B}: a \land V = a \end{cases}

9. Ley de absorción: \begin{cases} \forall a \in \mathbb{B}: a \lor (a \land b) = a \\ \forall a \in \mathbb{B}: a \land (a \lor b) = a \end{cases}

10. Ley de involución: \forall a \in \mathbb{B}: \lnot \lnot a = a

11. Ley del complemento: \begin{cases} \lnot V = F \\ \lnot F = V \end{cases}

12. Leyes de De Morgan: \begin{cases} \forall a,b \in \mathbb{B}: \lnot ({a \lor b}) = \lnot a \land \lnot b \\ \forall a,b \in \mathbb{B}: \lnot ({a \land b}) = \lnot a \lor \lnot b \end{cases}

3.5.0.1 Traducción a Python

3.5.0.2 Lógica binaria

• Otra forma de representar los operadores y los valores del álgebra de Boole es mediante la notación de la lógica binaria.

• Según la notación de la lógica binaria, los diferentes valores y operaciones del álgebra de Boole se representan de la siguiente forma:

  Valor u operación	Notación
  Valor verdadero	1
  Valor falso	0
  Producto de A y B	A \cdot B AB
  Suma de A y B	A + B
  Complemento de A	\overline{A}

3.6 Equivalencia lógica

• Decimos que dos expresiones lógicas P y Q son equivalentes (y se representa como P \equiv Q, aunque nosotros lo representaremos simplemente como P = Q) si tienen las mismas tablas de verdad, es decir, si se cumple que P vale V cuando Q también, y viceversa.

• Para demostrar que se cumple una equivalencia en el álgebra de Boole, se pueden usar dos técnicas:

  • Demostrar que la propiedad es un teorema que se puede deducir de los axiomas y de otros teoremas ya demostrados.

  • Usar las tablas de verdad para comprobar si los valores de verdad de P y Q coinciden exactamente.

3.7 El operador ternario

• Las expresiones lógicas (o booleanas) se pueden usar para comprobar si se cumple una determinada condición.

• Las condiciones en un lenguaje de programación se representan mediante expresiones lógicas cuyo valor (verdadero o falso) indica si la condición se cumple o no se cumple.

• Con el operador ternario podemos hacer que el resultado de una expresión varíe entre dos posibles opciones dependiendo de si se cumple o no una condición.

• El operador ternario se llama así porque es el único operador en Python que actúa sobre tres operandos.

• El uso del operador ternario permite crear lo que se denomina una expresión condicional.

4 Definiciones

4.1 Introducción

• Introduciremos ahora en nuestro lenguaje una nueva instrucción (técnicamente es una sentencia) con la que vamos a poder hacer definiciones.

• A esa sentencia la llamaremos definición, y expresa el hecho de que un nombre representa un valor.

• Las definiciones tienen la siguiente sintaxis:

  ⟨definición⟩ ::= identificador  =  ⟨expresión⟩

• Por ejemplo:

  x = 25

  A partir de ese momento, el identificador x representa el valor 25.

  Y si x vale 25, la expresión 2 + x * 3 vale 77.

4.2 Identificadores y ligaduras (binding )

• Los identificadores son los nombres o símbolos que representan a los elementos del lenguaje.

• Cuando hacemos una definición, lo que hacemos es asociar un identificador con un valor.

• Esa asociación se denomina ligadura (o binding).

• Por esa razón, también se dice que una definición crea una ligadura.

• También decimos que el identificador está ligado (bound).

• Lo representaremos gráficamente así:

• En Python (a diferencia de lo que ocurre en un lenguaje funcional puro) las ligaduras empiezan a existir en el momento en que se ejecuta su definición, no antes.

4.2.1 Ligaduras irrompibles

• En un lenguaje funcional puro, un identificador ya ligado no se puede ligar a otro valor. Por ejemplo, lo siguiente daría un error en un lenguaje funcional puro:

  x = 4  # ligamos el identificador x al valor 4
  x = 7  # intentamos ligar x al valor 7, pero ya está ligado al valor 4

• En consecuencia, las ligaduras entre nombres y valores no se pueden romper, de forma que un nombre, una vez ligado a un valor, no se puede volver a ligar a otro valor distinto durante la ejecución del programa (efecto que se conoce como rebinding).

• En la práctica, eso significa que el nombre representa un dato constante.

4.2.2 Inmutabilidad

• Para alcanzar la transparencia referencial, también es necesario que los objetos de datos que manipula el programa (es decir, los valores) no tengan un estado interno que pueda cambiar durante la ejecución del programa.

• Eso se consigue haciendo que los valores sean inmutables.

• Por ejemplo, en Python las cadenas son inmutables porque, una vez creadas, no se pueden cambiar los caracteres que la forman.

  Si hago x = "Hola", luego no puedo cambiar el interior de esa cadena (por ejemplo, cambiando la 'o' por una 'a'), porque entonces la expresión x tendría distintos valores dependiendo del momento en el que se evalúe, lo que va en contra de la transparencia referencial.

4.2.3 Reglas léxicas

• Cuando hacemos una definición debemos tener en cuenta ciertas cuestiones relativas al identificador:

  • ¿Cuál es la longitud máxima de un identificador?

  • ¿Qué caracteres se pueden usar?

  • ¿Se distinguen mayúsculas de minúsculas?

  • ¿Coincide con una palabra clave o reservada?

    • Palabra clave: palabra que forma parte de la sintaxis del lenguaje.

    • Palabra reservada: palabra que no puede emplearse como identificador.

• En Python, los identificadores pueden ser combinaciones de letras minúsculas y mayúsculas (y distingue entre ellas), dígitos y subrayados (_), no pueden empezar por un dígito, no pueden coincidir con una palabra reservada y pueden tener cualquier longitud.

4.2.4 Tipo de un identificador

• Cuando un identificador está ligado a un valor, a efectos prácticos el identificador actúa como si fuera el valor.

• Como cada valor tiene un tipo de dato asociado, también podemos hablar del tipo de un identificador.

  El tipo de un identificador es el tipo del dato con el que está ligado.

• Si un identificador no está ligado, no tiene sentido preguntarse qué tipo tiene.

4.3 Espacios de nombres

• Ciertas estructuras o construcciones sintácticas del programa definen lo que se denomina espacios de nombres.

• Un espacio de nombres (del inglés, namespace) es una correspondencia entre nombres y valores; es decir, es un conjunto de ligaduras.

• Su función es, por tanto, almacenar ligaduras y permitir varias ligaduras con el mismo nombre en distintas partes del programa.

• En un espacio de nombres, un identificador sólo puede tener como máximo una ligadura. En cambio, el mismo identificador puede estar ligado a diferentes valores en diferentes espacios de nombres.

• Por eso decimos que una ligadura es local al espacio de nombres donde se almacena, o que tiene un almacenamiento local a ese espacio de nombres.

• Los espacios de nombres pueden estar anidados, es decir, que puede haber espacios de nombres dentro de otros espacios de nombres, ya que también pueden estarlo las estructuras sintácticas que los definen.

4.4 Marcos (frames )

• Un marco (del inglés, frame) es una estructura que se crea en memoria para representar la ejecución o activación de un script de Python o una función o método definido por el programador en Python o Java.

• Los marcos son espacios de nombres y, entre otras cosas, almacenan las ligaduras que se definen dentro de ese script, función o método.

• Los marcos son conceptos dinámicos:

  • Se crean y se destruyen a medida que la ejecución del programa pasa por ciertas partes del mismo.

  • Van almacenando nuevas ligaduras conforme se van ejecutando nuevas instrucciones que crean las ligaduras.

4.5 Evaluación de expresiones con identificadores

• Podemos usar un identificador ligado dentro de una expresión, siempre que la expresión resulte ser válida según las reglas del lenguaje.

• El identificador representa a su valor ligado y se evalúa a dicho valor en cualquier expresión donde aparezca ese identificador:

  >>> x = 25
  >>> 2 + x * 3
  77

• Intentar usar en una expresión un identificador no ligado provoca un error de tipo NameError (nombre no definido):

  >>> y
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  NameError: name 'y' is not defined

4.5.1 Resolución de identificadores

• Durante la evaluación de una expresión, para cada uno de los diferentes identificadores que aparecen en ella, habrá que comprobar si ese identificador está ligado y a qué valor.

  • Si no está ligado, es un error de nombre no definido.

  • En caso contrario, tendrá que determinar a qué valor está ligado para poder sustituir, en la expresión, cada aparición del identificador por su valor.

• Para ello, habrá que buscar una ligadura con ese identificador en uno o varios espacios de nombres.

• El proceso de localizar (si es que existe) la ligadura adecuada que liga a un identificador con su valor, se denomina resolución del identificador.

• En general, al proceso de determinar con qué valores están ligados los identificadores de un programa se le denomina resolución de identificadores o resolución de nombres.

4.6 Scripts

• Cuando tenemos muchas definiciones o muy largas, resulta tedioso tener que introducirlas una y otra vez cada vez que abrimos una nueva sesión con el intérprete interactivo.

• Lo más cómodo es teclearlas todas una sola vez dentro un archivo que luego cargaremos desde dentro del intérprete.

• Ese archivo se llama script y, por ahora, contendrá una lista de las definiciones que nos interese usar en nuestras sesiones interactivas con el intérprete.

• Al cargar el script, se ejecutarán sus instrucciones una tras otra casi de la misma forma que si las estuviéramos tecleando nosotros directamente en nuestra sesión con el intérprete, en el mismo orden.

• Llegado el momento, los scripts contendrán el código fuente de nuestros programas y los ejecutaremos desde el intérprete por lotes.

4.7 Instalación de Visual Studio Code

• Instalación en Ubuntu:

  NO instalar Visual Studio Code desde el Centro de software de Ubuntu.

  En cambio, visitar https://code.visualstudio.com para descargar e instalar el paquete adecuado a la versión de Ubuntu que se está usando, que suele ser la que ya sugiere la propia página web (normalmente es el paquete .deb de 64 bits).

• Instalación en Windows:

  Visitar https://code.visualstudio.com, descargar e instalar la versión adecuada a la versión de Windows que se está usando.

4.7.1 Configuración básica de Visual Studio Code

1. Abrir la aplicación.

2. Acceder al apartado de Extensiones (Ctrl+Mayús+X) e instalar las siguientes extensiones:

   • Python

   • Python Indent

   • Pylance

3. Configurar las siguientes opciones:

   • Python: Language Server: Pylance

   • Python > Linting: Enabled: Activado

   • Python > Linting: Pylint Enabled: Activado

   • Python > Linting: Pylint Args:

     --disable=invalid-name,redefined-outer-name,missing-docstring,unnecessary-lambda-assignment

5 Resumen

5.1 Resumen

• Resumiendo, los conceptos fundamentales sobre los que se asienta la programación funcional son:

  • Casi todas las instrucciones son expresiones, no sentencias.
  • Definiciones, las únicas sentencias de un programa funcional.
  • Transparencia referencial.
  • Ausencia de efectos laterales.
  • Funciones puras.
  • El valor de una expresión no depende de nada ajeno a la misma, sólo de las subexpresiones que la forman.
  • Ligaduras irrompibles.
  • Inmutabilidad.
  • Las funciones también son valores.
  • Ejecutar un programa es evaluar una expresión.
  • No importa el orden en el que se ejecuten las instrucciones.
  • No importa el orden en el que se evalúen las subexpresiones de una expresión.

6 Documentación interna

6.1 Identificadores significativos

• Se recomienda usar identificadores descriptivos.

  Es mejor usar:

  ancho = 640
  alto = 400
  superficie = ancho * alto

  que

  x = 640
  y = 400
  z = x * y

  aunque ambos programas sean equivalentes en cuanto al efecto que producen y el resultado que generan.

• Si el identificador representa varias palabras, se puede usar el carácter de guión bajo (_) para separarlas y formar un único identificador:

  altura_triangulo = 34.2

6.2 Comentarios

• Los comentarios en Python empiezan con el carácter # y se extienden hasta el final de la línea.

• Los comentarios pueden aparecer al comienzo de la línea o a continuación de un espacio en blanco o una porción de código.

• Los comentarios no pueden ir dentro de un literal de tipo cadena.

  Un carácter # dentro de un literal cadena es sólo un carácter más.

  # este es el primer comentario
  spam = 1  # y este es el segundo comentario
            # ... y este es el tercero
  texto = "# Esto no es un comentario porque va entre comillas."