""

lunes, 3 de febrero de 2025

Curso Virtual Python UniAndes - Coursera / 2.10 Errores frecuentes

 

2.10. Errores frecuentes

En esta sección presentamos algunos de los errores que encontramos frecuentemente en los programas de muchos estudiantes. Revíselos con cuidado y asegúrese de entenderlos para no cometer esos mismos errores.

2.10.1. Errores con variables y asignaciones

2.10.1.1. Confundir una variable con una cadena

Cuando se empieza a programar, es habitual confundir el nombre de una variable con el valor de una cadena. Recuerde que el nombre de una variable nunca lleva comillas mientras que cualquier cosa entre comillas será un literal.

Considere el siguiente programa. Es más complicado, pero ha sido construido buscando para reflejar la confusión común.

1)>>variable = 'cadena' >># 'cadena' es un valor str almacenado en una variable de nombre variable.
 

2)>>cadena = 'variable' >># 'variable' es un valor str almacenado en una variable de nombre cadena.
 

3)>>lenguaje = 'python' # Nombre_variable: lenguaje; valor_almacenado: 'python'; tipo: str
 

4)>>print(cadena * 3)  # Nombre_variable:cadena; operación: valor_almacenado*3
 

5)>>print('cadena' * 3) # str 'cadena'*3 = 'cadena' 'cadena' 'cadena'='cadenacadenacadena'
 

6)>>print(python * 5) # Nombre_varible: python; operacion: valor_almacenado*5

  • En la línea 1, se crea una variable que se llama variable, es de tipo cadena (str) y tiene el valor 'cadena'.

  • En la línea 2, se crea una variable llamada cadena, es de tipo cadena (str) y tiene el valor 'variable'.

  • En la línea 3, se crea una variable llamada lenguaje, es de tipo cadena (str) y tiene el valor 'python'.

  • En la línea 4 se calcula el valor de repetir la variable cadena tres veces y se imprime. El programa imprime variablevariablevariable.

  • En la línea 5 se calcula el valor de repetir la cadena 'cadena' tres veces y se imprime. El programa imprime cadenacadenacadena. Note que en este caso no estamos haciendo referencia a la variable cadena sino a la cadena de caracteres 'cadena'.

  • Al intentar ejecutar la línea 6 se produce un error porque no existe ninguna variable con el nombre python.

2.10.1.2. Utilizar el valor de una variable a la que no se le ha asignado un valor

Para poder utilizar el valor contenido en una variable, se le debe haber asignado antes un valor. En este contexto, utilizar hace referencia a cualquier operación que dependa del valor que tenga una variable. Por ejemplo, en el siguiente programa las dos primeras instrucciones producirían un error mientras que la tercera no tendría ningún problema (suponiendo que antes de ejecutar el programa no exista la variable v).
 
1) >>v += 10
2) >>n = v * 10
3) >>v = 55
 
En el caso de las dos primeras instrucciones, el error que se presentaría sería similar al siguiente: 

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

2.10.1.3. Suponer que una asignación es también una ecuación

En un ejercicio de cálculo o de física es común que se usen ecuaciones para expresar el valor de una variable. Por ejemplo, la siguiente ecuación expresa el valor de la posición

en términos de la posición inicial , la velocidad inicial , la aceleración y el tiempo transcurrido:
 
 
 

La relación que describe la ecuación entre las variables mencionadas vale en todo momento, antes y después de que nosotros hayamos escrito la ecuación. El hecho de que nosotros la escribamos no cambia absolutamente nada.

Por el contrario, cuando nosotros escribimos una asignación en Python estamos indicando cuál va a ser el valor que tendrá una variable después de que se ejecute la instrucción. Considere el siguiente programa:

>>x = 27
>>x = y ** 3
 

Si interpretáramos el programa como si fuera un conjunto de ecuaciones, llegaríamos a la conclusión de que tiene que existir alguna variable y con el valor 3 para que x pueda valer 27 y también pueda valer y ** 3.

Si lo interpretamos como lo que es, un programa escrito en Python, la situación es muy diferente. Después de ejecutar la línea 1, la variable x asume el valor 27. Luego ejecutamos la línea 2 y le asignamos a x un valor que dependerá del valor de y. Si y tenía el valor 5, entonces el nuevo valor de x será 125 y el valor anterior se habrá perdido.

NOTA de PPI: Las dos instrucciones anteriores no contienen la definición de la variable y, por lo tanto se produce un error:

------------------------------------------------- 
NameError        Traceback (most recent call last)
<ipython-input-1-622beded6e5f> in <cell line: 0>()
      1 x = 27
----> 2 x = y ** 3
      3 x

NameError: name 'y' is not defined

 

 2.10.1.4. Intentar hacer una asignación de izquierda a derecha

Las asignaciones en Python se hacen de derecha a izquierda: el valor que se encuentre a la derecha del símbolo = se almacenará en la variable que se encuentre a la izquierda del símbolo. Si lo que hay a la izquierda no es una variable, se producirá un error. Si lo que hay a la derecha es una expresión, entonces se hará la evaluación de la expresión antes de almacenar el valor en la variable.

 

2.10.2. Errores definiendo funciones

2.10.2.1. No respetar la indentación

Python es estricto con respecto a la indentación y exige consistencia: si en una función las instrucciones se indentan de forma diferente se producirá un error como el siguiente:
 
>>>IndentationError: unexpected indent
 
 

2.10.2.2. Usar tabs en lugar de espacios

Una forma común (y fácil) de introducir el error de intentación es usar un caracter de tabulación en lugar de espacios. En este caso, Python nos anunciará algo similar a lo siguiente:

>>>TabError: inconsistent use of tabs and spaces in indentation 

Este error se introduce con facilidad al presionar la tecla tab pero no se detecta fácilmente porque para nuestros ojos una tabulación se ve igual que 4 u 8 espacios. Afortunadamente hoy en día muchos editores de código remplazan automáticamente las tabulaciones por 4 espacios, así que este error se presenta cada vez menos frecuentemente.

2.10.2.3. Usar en una función una variable definida en otra función

Considere el siguiente programa donde se definen dos funciones:

1 >>def fun1(a: int) -> int:
2 >>   doble = a * 2 

3>>   return doble

4>>def fun2(b: int) -> int:
5>>    resultado = b + doble
6>>    return resultado  
     

En la línea 6 hay un error porque se está intentando leer el valor de una variable llamada doble. Sin embargo, en el alcance de esta definición (es decir el espacio de las variables que se podrían leer) no hay ninguna variable con ese nombre. La única variable con ese nombre que vemos en el programa está definida dentro de la función fun1 pero debemos recordar que las variables que se definen dentro de una función son locales a esa función. Es decir que sólo existen dentro del contexto de esa función.

Si corremos el programa e invocamos a la función fun2 nos encontraremos con un error como el siguiente:

>>>NameError: name 'doble' is not defined

2.10.2.4. Usar en una función una variable definida por fuera de la función

A continuación presentamos algo que técnicamente no es un error pero es generalmente considerado una mala práctica de programación porque es fácil que lleve a errores muy difíciles de encontrar y resolver.

Considere el siguiente programa:

1>>
2>>
3>>
4>>
5>>
6>>
7>>
8>>
9>>
externo = 2

def fun1(a: int) -> int:
    valor = a * externo
    return valor
    
print(fun1(5))
externo = 3
print(fun1(5))

Teniendo en cuenta todo lo que hemos dicho hasta ahora, el programa debería fallar cuando se invoque a la función fun1 porque dentro de la definición de la función no existe una variable o un parámetro llamado externo. Sin embargo, el programa anterior funciona porque dado que no se encuentra el valor externo dentro del alcance de fun1, Python pasa al siguiente alcance (al del módulo que contiene la definición de la función). Como en este alcance, sí hay un valor para la variable externo, se usa este valor y no se produce el error al invocar a fun1.

Ahora bien, el hecho de que esto funcione no quiere decir que sea una buena idea aprovechar esta posibilidad para no tener que usar parámetros en las funciones. Como dijimos en la sección correspondiente, los parámetros de una función indican qué información es necesaria para ejecutar la función y calcular su resultado. En el programa de ejemplo esto es falso, puesto que el valor externo es absolutamente necesario para calcular fun1.

También dijimos que, si invocamos una función usando los mismos parámetros, es de esperarse que el resultado sea siempre el mismo. En este caso esto tampoco es cierto: el resultado de fun1 es diferente en las dos invocaciones debido al cambio en el valor de la variable externo.

Aunque no son los únicos argumentos posibles, por ahora deberían ser suficientes para mostrar que escribir funciones que dependan de valores definidos por fuera de la función es una mala idea (salvo casos muy especiales).

2.10.2.5. Ponerle a una variable el mismo nombre de una función

Es un reflejo común usar el nombre de una función para una variable en la que se almacene el resultado de la función, como en este ejemplo:

1
2
3
4
5
def sumatoria(a: int, b: int, c: int) -> int:
    return a + b + c
    
sumatoria = sumatoria(1, 2, 3)
sumatoria = sumatoria(4, 5, 6)

En este caso, el programa va a funcionar hasta la línea 4 y va a fallar en la línea 5 con un error como el siguiente:

>>>TypeError: 'int' object is not callable

Sin embargo, el eror se introdujo realmente en la línea anterior. Analicemos con cuidado lo que ocurre en esta línea:

  1. Se hace una invocación a la función sumatoria usando los parámetros 1, 2 y 3.

  2. El resultado de la invocación (el entero 6) se almacena en la variable sumatoria - que no existía antes de este momento.

En la siguiente línea se intenta hacer una invocación a sumatoria, pero Python lo último que vio con ese nombre no era una función sino una variable de tipo int, por lo cual genera el error diciendo que no es posible hacer una invocación sobre un entero.

2.10.2.6. Redefinir funciones nativas

A menos que haya alguna necesidad muy especial, nunca se deberían redefinir las funciones nativas de Python, tales como float, int, str, min, max y abs, entre otras. Sin embargo, en Python esto es realmente muy fácil de hacer y por lo tanto ocurre con frecuencia cuando se está empezando a programar.

Considere el siguiente ejemplo:

1
2
3
4
5
6
def menor(a: int, b: int, c: int) -> int:
    return min(min(a, b), c)
    
min = menor(5,7,3)
verificacion = min(5, 7, 3)
print(min, verificacion)

En esta función se define la función menor que busca el menor de 3 números aplicando la función min entre los dos primeros y luego la función min entre el tercero y el menor entre los dos primeros números. En la línea 4 se invoca a la función menor usando los valores 5, 7 y 3 y se almacena el resultado en la variable min. En la línea 5, se usa la función min con 3 parámetros para ver si el resultado es el mismo que con nuestra nueva función menor. Al ejecutar la línea 5 se produce el error y no se puede hacer la invoación:

>>>TypeError: 'int' object is not callable

Esto ocurre porque en la línea 4 creamos una variable llamada min de tipo entero y ahora Python no puede encontrar la función nativa min. El error en este caso es sencillo de corregir, pero también es fácil de introducir más adelante.

2.10.3. Errores con el retorno

2.10.3.1. Incluir una instrucción return en una función de tipo None

Si en la signatura de una función se declara que la función es de tipo None, no debería haber una instrucción return dentro de la función.

2.10.3.2. No retornar en una función

Fuera de las funciones que declaren en la signatura que son de tipo None, todas las funciones deberían incluir una instrucción return. Es recomendable, aunque no obligatorio, que sólo haya una instrucción return al final de la función.

2.10.3.3. Escribir instrucciones después del retorno

Las instrucciones que se escriban después de la instrucción return no se ejecutarán en un programa escribir instrucciones después del retorno

2.10.4. Otros errores

2.10.4.1. Olvidar el operador de multiplicación

Considere el siguiente programa:

1
2
a = m(m+1)/2
b = n*(n+1)/2

Probablemente el que escribió la primera línea quería realizar el mismo cálculo que en la línea 2 pero se le olvidó incluir el operador de multiplicación. Eso quiere decir que en la primera línea Python va a intentar invocar a la función m pasándole como parámetro el valor de m+1. Muy posiblemente esto no va a funcionar.

2.10.4.2. Confundir la concatenación de cadenas con la creación de tuplas

Más adelante en este libro estudiaremos un tipo de datos llamado tupla. Por ahora es suficiente decir que las tuplas son el tipo que uno usaría para representar cosas como coordenadas en un plano cartesiano (que tienen varias partes). En el siguiente código, en la primera línea se define una coordenada usando una tupla: note el uso de los paréntesis y de la coma para separar los valores 3 y 5.

1
2
3
coordenada_2D = (3, 5)
nombre_1 = 'Alberto' + ',' + 'García'  # nombre_1 es un str
nombre_2 = 'Alberto' , 'García'        # nombre_2 es una tupla

La segunda línea del programa crea una variable de tipo str con el valor "Alberto,García". Esto ocurre porque utilizamos el operador + entre cadenas de caracteres (concatenación) y concatenamos una cadena que tenía una coma (",") entre el nombre y el apellido.

En la tercera línea del programa no utilizamos el operador de concatenación, pero pusimos una coma entre el nombre y el apellido. En muchos lenguajes de programación se marcaría como un error de sintaxis, pero en Python esto corresponde a la creación de una tupla: la diferencia con la línea 1 es que en este caso no se utilizaron los paréntesis, que son opcionales cuando se crea una tupla, y que la nueva tupla tiene dos cadenas por dentro en lugar de dos números.

No se preocupe si no entiende lo que es una tupla en este momento. El punto importante es que no confunda una tupla con una cadena donde las partes estén separadas con comas.

2.11. Para no olvidar

  • Cada línea en programa debería tener una instrucción. Es más fácil de leer, entender, mantener y corregir un programa que tenga varias instrucciones sencillas, en lugar de uno donde cada línea intenta hacer varias cosas a la vez.

  • Las instrucciones de un mismo bloque se ejecutan una por una. Un bloque hace referencia a las instrucciones que están contenidas dentro del mismo módulo o de la misma función y que tienen el mismo nivel de indentación. Las instrucciones de un bloque se ejecutan desde la primera línea hasta la última, una por una. No son ecuaciones que tengan que ser ciertas todas a la vez.

  • Definir una función no es invocarla. A pesar de que se haya definido en la parte de arriba de un módulo, una función no necesariamente se va a ejecutar primero.

  • En la parte izquierda de una asignación siempre va una variable. No puede haber literales, ni expresiones, ni invocaciones de funciones en la parte izquierda de una asignación.

  • En una asignación, lo primero que se hace es evaluar el valor que está en la parte derecha. Sólo cuando ya se tiene un valor se asigna en la variable de la izquierda.

  • Es mejor usar nombres de variables explícitos y que sugieran su tipo. Por ejemplo, para guardar el teléfono de una persona es mejor utilizar una variable que se llame telefono a una variable que se llame numero. Esta última sería problemática si usáramos una cadena de caracteres, lo cual es muy usual dado que muchos teléfonos tienen otros caracteres además de los dígitos (como en +57 3394949 ext 2860).

  • Las funciones se invocan con su nombre y los valores para los parámetros dentro de paréntesis. Si una función no recibe parámetros, de todas formas es necesario incluir los paréntesis.

  • Los valores de los parámetros no tienen que llamarse igual que las variables que se usan al invocar la función. Por ejemplo, si tenemos la función con signatura {python} def f(a: int, b: float)-> float, no es necesario que tengamos variables llamadas a y b para hacer la invocación. En el siguiente programa todas las invocaciones serían correctas:

1
2
3
4
5
6
a = 1
b = 4.5
c = 7
r1 = f(a, b)
r2 = f(c, b)
r3 = f(c, 9.9)
  • Es una buena práctica usar comentarios. Si tiene dudas sobre si debería incluir un comentario en un cierto punto, mejor inclúyalo. Sea breve pero preciso en sus comentarios.


Curso virtual Python UniAndes - Coursera / 2.9 Logica vs Interacciòn

 

2.9. Lógica vs. Interacción


Objetivo de la sección

El objetivo de esta sección es presentar recomendaciones metodológicas para manejar la parte de los programas que se encarga de la interacción con los usuarios y la parte que se encarga de hacer los cálculos y otras operaciones.

Usualmente la preocupación más importante cuando se construye un programa es que sea correcto, es decir que sus cálculos y la forma en la que manipule la información que le dé un usuario sea correcta. Por ejemplo, lo más importante del sistema que manipula el dinero en un banco es que lleve correctamente las cuentas: nadie puede perder dinero, deben cobrar lo correcto por cada operación, el descuento de impuestos debe ajustarse a la ley y deben abonar los intereses correctamente calculados.

Además de la corrección, hay otras preocupaciones para tener en cuenta cuando se desarrolla un nuevo programa. Para un usuario, las preocupaciones comunes tienen que ver con la seguridad, el desempeño (qué tan rápido es el sistema) y la usabilidad (qué tan fácil de usar es). Desde el punto de vista de quien desarrolla un sistema, otras preocupaciones importantes son la escalabilidad (qué tan bien funcionará el sistema cuando tenga muchos usuarios o muchos datos), la tolerancia a fallos (cómo se comporta el sistema cuando ocurren ciertos problemas), o la interoperabilidad (qué tan fácil es que el sistema intercambie información con otros sistemas que ya existan) 1.

Sin embargo, la mayor preocupación para quien desarrolla un sistema debería ser la mantenibilidad. Esto quiere decir: qué tan fácil es hacerle un cambio a un sistema (ej. agregarle alguna funcionalidad, corregir algún error, mejorar su apariencia). Cuando se está aprendiendo a programar puede parecer que esta no es una cuestión importante y que lo prioritario son la corrección y el desempeño. La realidad es que una vez se empieza a usar un programa, siempre es necesario hacerle modificaciones, especialmente cuando es muy exitoso. Sólo piense en la cantidad de actualizaciones que tiene que instalar permanentemente en su computador o en su celular: con casi total seguridad usted no está utilizando la primera versión (1.0) de ninguna aplicación 2.

La pregunta natural que debería surgir es entonces: ¿cómo logramos que un programa sea mantenible? Ya en este capítulo discutimos la primera recomendación: documentando el código. Cuando el código está documentado es más fácil que otros programadores o nosotros mismos podamos hacer mejoras o correcciones a nuestros programas.

La segunda recomendación es incluso más importante: estructurando el programa de tal forma que sea fácil de entender. Esto significa que queremos que sea fácil entender cómo está organizado para que cuando haya un error sea fácil encontrar donde se debería corregir, o para que cuando se quiera agregar nuevas funcionalidades no se necesite una gran reestructuración.

Es posible que en este momento sea difícil para usted imaginarse la complejidad de un gran desarrollo porque hasta ahora sólo ha trabajado con pequeños programas. Con el tiempo se dará cuenta que las recomendaciones para organizar sus programas son tremendamente valiosas y que le ahorrarán mucho trabajo en el futuro. Acostúmbrese a estructurar bien sus programas mientras sean pequeños, para que sea natural hacerlo cuando sean grandes.

En esta sección estudiaremos una primera técnica para propiciar la mantenibilidad de los programas. Incidentalmente, para explicar esta técnica tendremos que introducir el concepto de módulo en Python. 
 

2.9.1. Separación de la lógica y la interfaz

Como hasta el momento hemos construido programas relativamente pequeños, hemos usado un solo archivo para cada uno. A partir de este momento vamos a empezar a separar los programas en dos módulos: uno para manejar la interacción con el usuario (pedirle datos, mostrarle información, etc.) y otro para manejar todo lo que consideramos la lógica del programa, es decir las instrucciones que son realmente el centro conceptual del programa.

Consideremos a modo de ejemplo, un programa que sirva para procesar información de un censo de población. El módulo con la interfaz de este programa servirá para que el usuario seleccione qué información quiere consultar y le mostrará las gráficas y tablas correspondientes. Por otro lado, la lógica del programa se encargará de calcular estadísticas, procesar los archivos y generar (¡no visualizar!) las gráficas que requiera el usuario.

Hay múltiples razones por los cuales esta separación es adecuada para programas como los que vamos a construir en este curso. La primera tiene que ver con el tipo de cosas que se hace en cada parte: mientras que en la interfaz todas las acciones deberían estar orientadas a interactuar con el usuario, en la lógica del programa hacemos cosas mucho más variadas. Con esto logramos que en cada módulo todo lo que hacemos esté relacionado: en lugar de tener funciones que le pidan información al usuario, hagan cálculos complejos y luego muestren el resultado, podemos tener en un módulo funciones dedicadas a la interacción y en otro módulo funciones dedicadas a hacer los cálculos.

Esta coherencia (o cohesión) termina llevando a programas que son mucho más fáciles de mantener porque dependiendo del tipo de error que se presente sabremos mejor dónde se debe corregir el código. La coherencia también se puede ver en el tipo de funciones que se utilizan: mientras en una interfaz basada en consola encontraremos muchos llamados a las funciones print e input, dentro de la lógica del programa encontraremos llamados muy diferentes que dependerán del problema que estemos resolviendo.

Otra ventaja de utilizar esta separación es que se vuelve más fácil probar la lógica de nuestros programas. Cuando la interfaz se mezcla con la lógica, para probar la corrección de un cálculo es necesario probar también la interfaz. Esto implica teclear datos cada vez y observar los resultados para compararlos con los esperados. Si la interfaz está separada de la lógica, podemos invocar directamente las funciones que hacen los cálculos, usando los mismos argumentos cada vez, es decir sin requerir la interacción con el usuario.

Otro motivo para utilizar esta separación tiene que ver con la reutilización. Veremos más adelante que las interfaces de muchos programas son muy similares y que hay mucho código que fácilmente se puede adaptar para utilizar en un nuevo programa. Si la interfaz estuviera mezclada con la lógica, esta reutilización sería mucho más difícil.

 

2.9.2. Implementación de módulos separados

Veamos ahora cómo se implementa en Python la separación entre la interfaz y la lógica de los programas. Para esto, tomaremos el programa ‘saludar.py’ que ya conocemos de una sección anterior:

 >>def saludar(nombre: str)-> str:
 >>return "Hola " + nombre + "!"

>>nombre = input("¿Cuál es su nombre? ")
>>saludo = saludar(nombre)
>>print(saludo)
 
Empezaremos primero con la creación del archivo con la lógica, al cual llamaremos ‘logica_saludar.py’.
 
>># Esto está en el archivo logica_saludar.py

>>def saludar(nombre: str)-> str:
>>   return "Hola " + nombre + "!" 

Como se puede ver, en este archivo únicamente dejamos la función que hace los “cálculos” del programa y crea un mensaje para saludar. Aunque el ejemplo es extremadamente sencillo, es importante notar que en este archivo no se está usando ni la función print ni la función input.

Otra cosa importante para analizar es lo que pasaría si decidiéramos ejecutar este módulo usando la siguiente instrucción en la línea de comandos: python logica_saludar.py.

2.9.3. Funciones de la interfaz

En una sección anterior hablamos de la conveniencia de tener funciones sin parámetros o funciones sin retorno. En esta sección podemos retomar la discusión puesto que es precisamente en el módulo que implementa la interfaz de un programa donde tiene más sentido incluir este tipo de funciones.

2.9.3.1. Funciones sin parámetros

Como dijimos antes, una función sin parámetros no tendría sentido dentro de la definición matemática de función. En el caso de Python, una función cuyo resultado no dependiera de ningún valor externo tampoco tendría mucho sentido; sería mucho más eficiente y claro implementarlo como una constante.

Sin embargo, dentro del módulo de la interfaz sí puede ser conveniente tener funciones sin parámetros. Tomemos como ejemplo el siguiente fragmento de código:

>>import libreria

>>def calcular_area_cuadrado() -> float:
>>    str_lado = input("Por favor indique el lado del cuadrado: ")
>>    lado = float(str_lado)
>>    area = libreria.calcular_area(lado)
>>    return area

 
En este programa tenemos una función sin parámetros que retorna un número decimal, pero ese número puede variar con cada ejecución. De hecho, el resultado de esta función depende completamente de algo externo: el valor que el usuario teclee cuando se ejecute la función.

Esta situación es muy frecuente dentro de los módulos que implementan la interfaz y que reciben información del usuario. Desconfíe de una función que no reciba parámetros y se encuentre mezclada con funciones que tengan que ver con la lógica de la aplicación: probablemente sea un error de diseño y sea necesario cambiar la signatura de la función.

2.9.3.2. Funciones sin retorno

En el módulo donde se implementa la interfaz también es posible tener funciones que no tengan un retorno. Estas funciones se suelen llamar procedimientos porque no cumplen con la característica básica de una función de producir un resultado.

El siguiente fragmento nos muestra una función de la interfaz que no tiene un retorno:

>>def mostrar_resultado(resultado: str) -> None:
>>    print("El resultado es:", resultado)

Observe que a diferencia de casi todas las funciones que hemos visto hasta ahora, esta no incluye una instrucción de tipo return. Esto quiere decir que, si alguien invoca a esa función, no va a recibir un resultado. Para expresar esto en la signatura, el tipo de retorno de la función se ha declarado como None. Más adelante veremos que None se utiliza para varias cosas en Python.

El cuerpo de la función sólo tiene un llamado a la función print. Esta función, que sirve para mostrar algún texto en la consola, es la que está produciendo un resultado, aunque no sea un resultado que se pueda utilizar dentro del programa en instrucciones siguientes 3
 

2.9.4. Ejercicios

  1. ¿Sólo con base en la signatura y lo que sabe hasta ahora, usted pondría las siguientes funciones en el módulo de la interfaz o en la librería de su programa?

  • def funcion(param1: int, param2: int) -> int

  • def funcion() -> int

  • def funcion(param1: int) -> None

  • def funcion(param1: int) -> int

 

2.9.5. Más allá de Python

La primera parte de esta sección introdujo algunos temas relativamente avanzados que tienen que ver con una gran área de trabajo dentro de la informática llamada Ingeniería de Software. La principal preocupación de esta área es cómo hacer para construir de forma eficiente software con calidad, lo cual implica considerar aspectos como la forma de estructurar el software, las metodologías de trabajo en los proyectos de desarrollo, las técnicas para diseñar interfaces que ofrezcan una buena experiencia a los usuarios, y hasta la psicología de los desarrolladores.

Es indudable que la selección de los lenguajes de programación que se usen tiene un impacto en muchos de los otros aspectos que son de interés para la Ingeniería de Software. Por ejemplo, el uso de un lenguaje como Python parece acelerar el desarrollo de programas pequeños, pero complica el mantenimiento de programas grandes debido a factores como el uso de un sistema de tipado dinámico.

Esto no quiere decir que no se pueda usar Python exitosamente para proyectos grandes. Lo que queremos decir es que la selección del lenguaje de programación debe tener en cuenta una gran cantidad de factores que van mucho más allá de cuál es el lenguaje de moda, cuál es el lenguaje que conocemos o cuál es el lenguaje que nos gustaría aprender. Todos los lenguajes tienen ventajas y desventajas que se deben sopesar cuidadosamente, y después de tomar una decisión cualquier proyecto debería introducir instrumentos para mitigar los riesgos o el impacto cuando se materialicen esos riesgos.

Por ejemplo, si se decide usar un lenguaje como Python o JavaScript para un gran proyecto, deberían definirse varias reglas desde el inicio para contrarrestar la dificultad para aplicar operaciones de refactoring 4.

En casi cualquier lenguaje de programación existen mecanismos similares a los módulos para descomponer programas y poder reutilizar bloques. Estos mecanismos también definen espacios de nombres (namespaces). Es decir que agrupan elementos para que los nombres no tengan que ser únicos dentro de todo el programa, y en lugar de eso sean únicos dentro de cada espacio de nombres. En Java y otros lenguajes orientados a objetos los mecanismos básicos de modularización son las clases, aunque también existen otros mecanismos como los paquetes y las librerías empaquetadas.


1

Las preocupaciones de las que hemos estado hablando se conocen usualmente como Requerimientos No Funcionales o como Atributos de Calidad. Aunque usualmente son un tema que se estudia más adelante, no está de más empezar a usar esta terminología y empezar a tener una sensibilidad hacia estas problemáticas. Pensar únicamente en la corrección del software y en construir programas lo más rápidamente posible nos ha llevado a una situación en la que tenemos cada vez más software que es inútil y tiene que botarse a la caneca y reconstruirse.

2

Si se compara el tiempo que toma el desarrollo inicial de un software y el tiempo que dura su mantenimiento posterior, en la mayoría de casos de software exitoso se va a encontrar que el mantenimiento se lleva la mayor parte del tiempo. Por ejemplo, el software que utilizan muchos bancos del mundo en su core, o el software que usan las aerolíneas para el control de vuelos y reservas, o el software que utilizan las empresas de telecomunicaciones para hacer conexiones entre redes, se construyó hace decenas de años, usando tecnologías que hoy ni siquiera se enseñan ya. La tecnología y las necesidades, especialmente de integración, han cambiado, lo cual ha obligado a hacerles actualizaciones permanentes a estos sistemas: si no fuera porque estos sistemas se construyeron para garantizar su mantenibilidad, hace muchos años que habrían tenido que ser remplazados y las empresas que los usan habrían tenido que incurrir en costos altísimos que podrían hasta haberlas quebrado.

3

Esto es lo que se conoce como un efecto de borde de un programa. Otros efectos de borde típicos son escribir en un archivo y enviar un mensaje por la red.

4

Refactoring es el término utilizado para procesos en los que el código fuente de un programa se restructura para mejorarlo pero sin cambiar su comportamiento. Por ejemplo, es común que se apliquen operaciones de refactoring para hacer que un programa sea mucho más fácil de mantener cambiando el nombre de las funciones para que sean naturales o para que se ajusten a estándares.

domingo, 2 de febrero de 2025

Curso virtual de Python UniAndes-coursera / 2.8 Un programa para leer (2)

 

2.8. Un programa para leer (2)

Volvemos ahora al programa completo que usted leyó al inicio del capítulo. Vuelva a leerlo detenidamente: todo lo que aparece en este programa ya lo estudiamos y usted debería estar en capacidad de entenderlo.

>># Este programa está escrito en el archivo perimetro.py

>>def perimetro_triangulo(cateto1: float, cateto2: float)->float:

    """
>>    Esta función calcula el perímetro de un triángulo rectángulo
>>    dada la longitud de sus dos catetos
>>    Parámetros:
>>      cateto1 (float): la longitud del primer cateto del triángulo
>>      cateto2 (float): la longitud del segundo cateto del triángulo
>>    Retorno
>>      (float): la longitud del perímetro del triángulo
    """    

>># Usar la función calcular_hip para calcular la longitud del lado faltante
>>    hipotenusa = calcular_hip(cateto1, cateto2)
    
>>    # Sumar los tres lados y convertirlos en la respuesta de la función
>>    return cateto1 + cateto2 + hipotenusa



>>def calcular_hip(cateto1: float, cateto2: float)->float:
    """
>>    Esta función calcula la longitud de la hipotenusa en un triángulo rectángulo
>>    dada la longitud de sus dos catetos
>>    Parámetros:
>>      cateto1 (float): la longitud del primer cateto del triángulo
>>      cateto2 (float): la longitud del segundo cateto del triángulo
>>    Retorno
>>      (float): la longitud de la hipotenusa
    """

>>    # Sumar la longitud de los catetos elevados al cuadrado
>>    suma_cuadrados = (cateto1 ** 2) + (cateto2 ** 2)
    
>>    # Calcular la raiz cuadrada de la suma usando la función pow y el exponente 0.5
>>    hipotenusa = pow(suma_cuadrados, 0.5)
>>    return hipotenusa



>># Solicitarle al usuario la longitud de los dos catetos
>>cadena_cat_1 = input("Indique la longitud del primer cateto: ")
>>cadena_cat_2 = input("Indique la longitud del segundo cateto: ")

>># Convertir los caracteres dados por el usuario en un número decimal
>>cat_1 = float(cadena_cat_1)
>>cat_2 = float(cadena_cat_2)

>># Llamar a la función con los valores recibidos
>>perimetro = perimetro_triangulo(cat_1, cat_2)

>># Mostrarle al usuario el resultado de la operación
>>print("El perímetro de un triángulo rectángulo que tenga catetos de longitud", cat_1, "y", cat_2, "es", perimetro)

 

Preguntas: A partir de su lectura del programa, intente responder las siguientes preguntas.

  • ¿Cuál es el objetivo del programa?

  • ¿Qué información tendrá que suministrar el usuario que ejecute el programa?

  • ¿Cuál es el objetivo de cada bloque?

  • ¿Qué es lo que primero se ejecuta?

  • ¿Cual es la diferencia entre las cosas que están escritas en español y las que están escritas en inglés?

  • ¿Cuáles son los valores que tiene que proporcionar el usuario?

  • ¿Qué ve el usuario al finalizar la ejecución?

     

    2.8.1. Ejercicios

    1. Copie el programa a su computador y ejecútelo. Hágale modificaciones y observe los cambios que se producen en sus resultados.

    2. Escriba un programa completo que le pida al usuario la temperatura actual en grados Celsius y le informe cuál es esa temperatura en Fahrenheit.

    Observe la siguiente figura:

    Ejercicio Área 

    3. Construya un programa que le pida al usuario la medida del lado del cuadrado y le informe al usuario el tamaño del área de la zona negra.

 

Curso Python UniAndes - Coursera / 2.7 Estilo de programaciòn

 

2.7. Estilo de programación

Objetivo de la sección

El objetivo de esta sección es introducir algunos elementos que no son obligatorios al programar pero que hacen el código mucho más comprensible y fácil de mantener.

En las secciones anteriores hemos empezado a estudiar la sintaxis de Python, es decir las reglas que define el lenguaje y que deben respetarse en todos los programas que se escriban con él: si las reglas sintácticas no se cumplen, el intérprete de Python no podrá entender lo que quiere decir el programa y no podrá ejecutarlo. Sin embargo, la sintaxis no lo es todo en un lenguaje de programación. También es importante pensar en el estilo.

Si bien las reglas de Python parecen muy estrictas, hay infinidad de formas diferentes en las que se puede escribir el mismo programa. Esto incluye desde cambios menores, como incluir líneas en blanco o comentarios adicionales, hasta cambiar la descomposición en funciones, pasando por cambios en los nombres de las variables y de las funciones. Es decir que dos personas que escriban el mismo programa Python pueden terminar escribiendo programas muy diferentes sólo por utilizar un estilo diferente.

El problema con esta gran libertad es que las decisiones que tomemos con respecto al estilo del código que escribamos hoy posiblemente nos van a acompañar durante mucho tiempo. La mayoría de los programas se escriben en un tiempo relativamente corto (días o semanas) y luego se utilizan, se corrigen y se actualizan durante meses o años. Si hoy tomamos decisiones que parecen fáciles (como utilizar nombres de variables cortísimos o no descomponer una función muy complicada), es posible que más adelante sea más difícil arreglar un problema porque no podremos entender con facilidad nuestro propio código.

Any fool can write code that a computer can understand. Good programmers write code that humans can understand.

—Martin Fowler

Para ilustrar este punto, revisemos el siguiente programa basado en las funciones que usamos en la sección anterior:

>>def area_cuadrado(lado: int)-> int:
>>    """ Calcula el área de un cuadrado dada la medida de su lado
>>    Parámetros:
>>        lado (int): La medida del cuadrado
>>    Retorno:
>>        (int): El valor del área del cuadrado. Es siempre un número entero.
>>    """
>>    return lado * lado



>>def area_triangulo(base: int, altura: int)-> float:
>>    """ Calcula el área de un triángulo.
>>    Parámetros:
>>        base (int): La medida de la base del triángulo.
>>        altura (int): La medida de la altura del triángulo.        
>>    Retorno:
>>        (float): El valor del área del triángulo. Es siempre un número decimal.    
>>    """   
>>    return (base * altura) / 2



>>def area_casa(frente: int, techo: int)-> float:
>>    """ Calcula el área del dibujo de una casa que se forma con un cuadrado
>>        y un triángulo encima (el techo).
>>        El frente de la casa será igual al lado del cuadrado y a la base del triángulo.
>>        La altura del techo será la altura del triángulo.
>>    Parámetros:
>>        frente (int): La medida del frente de la casa.
>>        techo (int): La medida de la altura del techo de la casa.        
>>    Retorno:
>>        (float): El valor del área del dibujo de la casa.        
>>    """
>>    cuadrado = area_cuadrado(frente)
>>    triangulo = area_triangulo(frente, techo)
>>    return cuadrado + triangulo

>>print(area_casa(10, 5))
 

Ahora revisemos un segundo programa:

>>def f(b, c):
>>    v = (b * b) + (b * c)/2
>>    return v
    
>>print(f(10, 5))  
  

Aunque a primera vista no es evidente, los dos programas son equivalentes en el sentido de que al ejecutarlos el resultado será el mismo: imprimirán el valor 125.0 en la consola. Evidentemente el segundo programa es mucho más corto que el primero, pero esto no necesariamente es una ventaja. En este caso es difícil entender que la función f sirve para calcular el área del dibujo de la casa y requiere como parámetro las medidas del frente y del techo, en ese orden.

Podemos decir que las diferencias entre los dos programas se reducen a los siguientes 5 aspectos:

  1. Utilizar nombres claros para las variables, las funciones y los parámetros.

  2. Documentar el objetivo de cada función

  3. Descomponer las funciones para que cumplan objetivos precisos

  4. Complejidad de las instrucciones

  5. Indicar los tipos de los parámetros y retornos de las funciones

A continuación revisaremos cada uno de estos puntos con un poco más de detalle.

2.7.1. Nombramiento de variables y funciones

Uno de los factores que más incide en la facilidad para comprender un programa es la selección de nombres para variables y funciones: si el nombre que utilizamos para una variable o una función es bueno, no tendremos que pensar mucho para recordar qué rol tiene dentro del programa y podremos concentrarnos en los aspectos importantes.

En el ejemplo que presentamos antes podemos ver esto claramente:

>>def area_triangulo(base: int, altura: int)-> float:
>>    return (base * altura) / 2

>>def g(b, c):
>>    return (b * c)/2

Las dos funciones anteriores hacen los mismos cálculos, pero la primera es claramente más explícita: no tenemos que hacer un gran esfuerzo para descubrir cuál es su objetivo.

Use buenos nombres de variables:

Para las variables, utilice nombres que indiquen con claridad qué es lo que va a guardar dentro de ellas. Evite nombres muy cortos a menos que no haya ninguna ambigüedad posible.

Use buenos nombres de funciones:

Para las funciones, utilice nombres que indiquen qué es lo que hará la función. Incluya verbos en los nombres de funciones (ej. guardar_resultado ), a menos que se pueda sobreentender con facilidad (ej. calcular_area_triangulo vs. area_triangulo).

 

2.7.1.1. Estándares

Más allá de los nombres y de lo que significan, en cada lenguaje también hay estándares para el uso de mayúsculas y minúsculas y la separación de palabras en los nombres de variables y funciones. Estos estándares pueden parecer arbitrarios (¡y lo son!) pero es importante respetarlos porque seguirlos consistentemente hace mucho más sencilla la lectura del código.

En Python, las reglas más importantes en este sentido son las siguientes:

  1. Usar snake_case. Esto significa que las palabras de un identificador deberían separarse usando el caracter '_'. Por ejemplo, en Python se prefiere usar calcular_area_triangulo mientras que en Java se usaría calcularAreaTriangulo.

  2. Usar minúsculas para los identificadores. Tanto funciones como variables y parámetros deberían nombrarse usando minúsculas.

  3. Usar Mayúscula Inicial para los nombres de clases 1.

  4. Usar MAYÚSCULAS SOSTENIDAS para las constantes. Aunque estrictamente hablando en Python no existe el concepto de constante, se suelen usar mayúsculas sostenidas para indicar que el valor de una variable no debería cambiar su valor. Por ejemplo, ROJO o IVA. Desafortunadamente una de las constantes más útiles, math.pi, no sigue este estándar.

Use el alfabeto inglés:

Aunque en Python es posible utilizar en los identificadores caracteres que existen en el español pero no existen en inglés, como la ñ y las vocales acentuadas, es recomendable evitarlo para evitar problemas de codificación. Esto es especialmente importante si se va a usar el mismo código en máquinas Windows, Linux y Mac

 

2.7.2. Documentación de funciones

Un segundo aspecto para facilitar el uso de nuestro código es documentar las funciones con un comentario que le sirva a potenciales usuarios o a nosotros mismos. De esta forma no será necesario estudiar con detenimiento el cuerpo de la función para saber qué hace.

Para cada función usualmente queremos saber 4 cosas:

  1. cuál es su objetivo

  2. cómo se debe usar

  3. qué pasará cuando se use

  4. cómo deben usarse y qué representan los parámetros

En Python el comentario con múltiples líneas que se encuentre justo después de la signatura de una función es considerado la documentación de la función. Esto usualmente se conoce como el docstring de una función y tiene una característica muy importante: cuando busquemos ayuda sobre una función, usando la función nativa help, recibiremos el docstring. Veamos un ejemplo en el que primero definiremos una nueva función y especificaremos su docstring.

 >>def area_triangulo(base: int, altura: int)-> float:
 >>   """ Calcula el área de un triángulo a partir de su base y su altura.
 >>       Tanto la base como la altura deben ser números enteros.
 >>       El resultado es un número decimal aunque los parámetros sean enteros.
 >>   """
 >>   return (base * altura) / 2

 Si después de definir nuestra función invocamos la función nativa help usando nuestra función como parámetro, obtendremos la documentación que especificamos.

 >>> help(area_triangulo)
>>>Help on function area_triangulo in module __main__:

>>>area_triangulo(base: int, altura: int) -> float
>>>    Calcula el área de un triángulo a partir de su base y su altura.
>>>    Tanto la base como la altura deben ser números enteros.
>>>    El resultado es un número decimal aunque los parámetros sean enteros.

 Ahora bien, a diferencia de otros lenguajes Python no especifica cómo deben describirse los detalles de una función: sólo nos da el espacio para que escribamos la documentación y nos da total libertad para que nosotros decidamos qué aspectos queremos documentar. Es nuestra responsabilidad decidir qué incluir y asegurarnos de que la documentación sea suficiente para que alguien más pueda usar nuestra función. También es nuestra responsabilidad definir cómo vamos a organizar la información para que esté organizada y sea fácil de encontrar y utilizar.

Toda esta libertad que da el lenguaje ha llevado a que existan varios estándares para documentar las funciones sin que ninguno sea claramente superior a los otros. Aunque le recomendamos que más adelante escoja uno de los estándares, por ahora le recomendamos utilizar la versión simplificada que se ilustra en el siguiente ejemplo:

   >>""" Calcula el área de un triángulo a partir de su base y su altura.
   >>Parámetros:
   >>     base (int): La medida de la base del triángulo.
   >>                 Debe ser un número estrictamente positivo (mayor o igual a 1).
   >>     altura (int): La medida de la altura del triángulo.
   >>                 Debe ser un número estrictamente positivo (mayor o igual a 1).      
   >> Retorno:
   >>     (float): El valor del área del triángulo. Es siempre un número decimal.    
   >>  """  

  Esta documentación incluye los siguientes elementos:

  1. Descripción de la función. Acá explicamos cuál es el objetivo de la función para que sea fácil saber si es la función que necesitamos usar. Además, si la función es muy complicada, explicamos qué es lo que hace la función por dentro. Esta descripción puede ocupar múltiples líneas: le recomendamos que no use líneas muy largas y que intente que el texto quede bien alineado a la izquierda.

  2. Parámetros. Si la función tiene parámetros, especificamos el nombre y el tipo de cada uno, seguidos de una descripción. La idea es que quien vaya a utilizar la función se entere de qué representa el parámetro y de todas las reglas que deberían aplicarse.

  3. Retorno. Acá explicamos qué es lo que retorna la función.

Para una función tan sencilla como la del ejemplo, puede parecer que esta descripción tan grande es exagerada. Pronto estaremos trabajando con funciones mucho más complicadas en las que será muy importante que escribamos una documentación muy completa para que no nos confundamos nosotros mismos o confundamos a las personas con las que estemos trabajando.

 Documente sus funciones:

Documente siempre sus funciones utilizando un formato consistente que incluya una descripción general y la explicación detallada de los parámetros y el retorno.

2.7.2.1. Ejercicios

  1. Use la función help para consultar la documentación de algunas de las funciones nativas que ya ha estudiado.

  2. Escriba la documentación de alguna función que haya desarrollado en un ejercicio previo. Revise en el intérprete de Python que pueda leer la documentación de la función usando la función help.

     En PPI para dar respuesta a estos ejercicios lo vamos a hacer con ejercicios planteados por el profesor Argentino Alfredo del conocido recurso educativo gratuito aprende con Alf.

    Ejercicio 1

    Escribir una función que muestre por pantalla el saludo ¡Hola amiga! cada vez que se la invoque.

    Solución:

    El código para dar solución al ejercicio 1 de la sección de funciones del profesor Alfredo es la siguiente:

    >>print('Inicio de ejercicio 1')
    >># Solucion de PPI (python para ingenieros)
    >>def saludo()->str:
    >>  """Esta funcion muestra por pantalla el saludo ¡Hola amiga! sin utilizar ningun parametro y >>la salida es tipo str."""
    >>  return print("¡Hola amiga!")

    # LLamamos o invocamos la funcion:


    >>saludo()
    >>print('Fin de ejercicio 1')

    #Se obtiene la respuesta de la consola como:

    >>>Inicio de ejercicio 1
    >>>¡Hola amiga!
    >>>Fin de ejercicio 1

    #Consultemos ahora el docstring de la funcion saludo(): 

    >>help(saludo)
    >>>Help on function saludo in module __main__:
    
    >>>saludo() -> str
    >>>    Esta funcion muestra por pantalla el saludo ¡Hola amiga! sin utilizar 
    >>>ningun parametro y la salida es tipo str.
    

    2.7.3. Descomposición de funciones

    Aunque no se puede generalizar, en lo posible deberíamos tener funciones sencillas que se compongan poco a poco para formar funciones más complicadas. Esto es preferible a tener funciones extremadamente complicadas que se tengan que leer con muchísima atención: al leer el código de una función debería ser claro cuál es su objetivo principal y cómo lo está logrando.

    Para lograr una buena descomposición es necesario primero hacer abstracción de las funciones, separando la signatura de la implementación. Es decir, debemos pensar en qué se quiere lograr con una función independientemente de cómo se vaya a implementar. El proceso se debe repetir identificando funciones cada vez más sencillas que sirvan para explicar cómo se resuelven las funciones más grandes, pero sin entrar en detalles, hasta que lleguemos a funciones triviales. En una sección posterior estudiaremos en mucho más detalle este proceso que se conoce como refinamiento a pasos.

     Simplifique sus funciones

    Intente tener funciones que tengan un único objetivo y que sean fáciles de explicar. Si usted descubre que el objetivo o la implementación de una función son muy complicados de explicar, posiblemente sea una señal de que debe descomponerla en funciones más pequeñas.

    El siguiente motivo por el cual tiene sentido descomponer las funciones es para evitar la repetición de código. En general, tener código repetido es mala idea porque aumenta la posibilidad de tener errores y porque, en caso de querer corregir un error, será necesario hacerlo en muchos lugares.

    Use funciones para evitar repeticiones

    Si está repitiendo el mismo código en varios lugares, considere construir una función que encapsule esa funcionalidad y que pueda llamar en todos los lugares donde lo requiera

    2.7.4. Complejidad de las instrucciones

    Una razón por la cual muchas veces el código es mucho más difícil de leer y entender de lo necesario es porque se hacen muchas acciones dentro de la misma instrucción. A manera de ejemplo a continuación presentamos dos funciones equivalentes que calculan el área de un polígono regular a partir de la longitud de un lado y de la cantidad de lados:

    >>import math

    >>def area_poligono(lado: float, num_lados: int) -> float:
    >>    return (num_lados * lado**2) / (4 * math.tan(math.pi / num_lados)) 

    >>import math

    >>def area_poligono2(lado: float, num_lados: int) -> float:
    >>    angulo_interno_radianes = math.pi / num_lados
    >>    numerador = num_lados * lado**2
    >>    denominador = 4 * math.tan(angulo_interno_radianes)
    >>    return numerador / denominador 

    Aunque el primer ejemplo no es extremadamente complicado, la única instrucción que tiene es mucho más complicada que cualquiera de las instrucciones del segundo ejemplo. Esto significa que el segundo ejemplo será más fácil de leer y probablemente fue más fácil de construir que el primero.

    Simplifique las instrucciones:

    • Escriba instrucciones que sean lo más sencillas posibles.
    • Idealmente, cada línea de código debería hacer una sola cosa

    2.7.5. Tipado de funciones y parámetros

    Si usted utiliza otros libros o si consulta en Internet, es muy posible que se encuentre con definiciones de funciones en las que no aparecen los tipos de los parámetros ni el tipo de los resultados. Esto se debe a que en Python el uso de estos elementos es opcional. De hecho, el nombre específico de estos elementos es type-hints y las herramientas (IDE, intérprete, compilador, etc.) los utilizan sólo como sugerencias.

    En este libro vamos a usar type-hints en la definición de todas las funciones y esperamos que usted haga uso de ellos también. Por una parte, esto le facilitará aprender a usar otros lenguajes de programación como C, C++, Java, o TypeScript. Por otro lado, razonar sobre los tipos de datos debería ayudarlo a estructurar mejor sus programas, especialmente mientras adquiere una cierta destreza programando.

    Utilice type-hints

    Utilice los type-hints para todos los parámetros y los retornos de las funciones. No sólo harán que su código sea más legible y fácil de usar, sino que además lo prepararán a usted para utilizar otros lenguajes.

    2.7.6. Comentarios

    Por último, hay un aspecto adicional que es muy sencillo pero tiende a mejorar la calidad del código: introducir comentarios dentro de las instrucciones. En los ejemplos que introducimos al principio de la sección eso no se estaba haciendo porque las funciones utilizadas eran muy sencillas, pero en funciones como las que estudiaremos a partir de la próxima sección esto será mucho más importante.

    En general deberían incluirse comentarios dentro del código para explicar el funcionamiento de bloques de código que sean particularmente complicados. No existe ningún estándar sobre esos comentarios, pero a continuación le damos algunas recomendaciones:

    1. No exagere con los comentarios. Así como la falta de comentarios es grave, el exceso de comentarios puede terminar en código muy difícil de leer.

    2. Escriba comentarios que expliquen lo que hacen fragmentos significativos de código y/o su justificación, en lugar de hacer una traducción de Python a español de las instrucciones realizadas.

    3. Identifique las instrucciones particularmente complicadas y documéntelas.

    4. En funciones medianas o largas que no pueda o no quiera descomponer, enumere las grandes etapas usando comentarios.

      2.7.7. Ejercicios

      1. Revise detenidamente la siguiente función para descubrir su objetivo. Reescribirlo aplicando las recomendaciones que se estudiaron en esta sección.

     >>def vc(r, a) :
     >>   b = 3.14159 * (r**2)
     >>   return round(b * a,2)

    Solución al item 1. Fuente:PPI :

    Nombre de la función: vc, supongo que representa el volumen de un cilindro.

    Parámetros: r, a; al parecer r, representa el radio de una circunferencia; y a, representa la altura de un cilindro.

    Retorno: el producto del area de la base  por la altura, es decir el volumen del cilindro.

    Objetivo: Calcular el volumen de un cilindro dados el readio y la altura del cilindro.

    Reescribiendo la función quedaría así:

    >>def calcular_volumen_cilindro(radio:float, altura:float)->float:

    """La funcion permite calcular el volumen de un cilindro en funcion del radio de la base y la altura del cilindro. La respuesta se redondea a dos cifras decimales"""

    >>      area_base = 3.14159 *(radio**2)

    >>      return round(area_base *altura,2)

    2. Revise detenidamente la siguiente función para descubrir su objetivo. Reescribirlo aplicando las recomendaciones que se estudiaron en esta sección. 

    >>def v(d):
    >>    vf = (2*9.8*d)**(1/2)
    >>    return vf

    Solución de PPI al item 2:

    >>def calcular_velocidad(distancia:float)->float:
    >>"""Esta función es para calcular la velocidad final de un movimiento, en función de la distancia o desplazamiento del cuerpo en metros"""
    >>     velocidad_final = (2*9.8*distancia)**(1/2)     # también math.sqrt(2*9.8*distancia)
    >>     return velocidad_final

    2.7.8. Más allá de Python

    Comparado con otros lenguajes, el formato para la documentación de funciones en Python es relativamente pobre y desestructurado. En Java existe el formato Javadoc que es muy estructurado y permite generar automáticamente compendios con la documentación de un programa o una librería. Esquemas similares existen para otros lenguajes como JavaScript (JSDoc) y Scala (Scaladoc). Aunque no se puedan usar directamente en Python, vale la pena conocer un poco sobre las características de estos formatos (y las limitaciones que tienen) para mejorar la documentación que escribamos de las funciones Python.

    La discusión sobre los type-hints tiene que ver con una discusión mucho más extensa sobre la conveniencia de tener tipado dinámico en los lenguajes de programación. Por un lado, cuando los lenguajes son fuertemente tipados se cometen menos errores o, al menos, las herramientas de edición capturan más errores de forma temprana. Por otro lado, cuando el tipado es dinámico los errores de tipo se capturan en tiempo de ejecución, pero el desarrollo de los programas es más rápido. En este momento hay fuertes discusiones sobre la conveniencia o no de cada sistema, pero hay un hecho que encontramos muy diciente: JavaScript, que tiene tipado dinámico, está incluyendo progresivamente más elementos para escribir programas fuertemente tipados (el crecimiento de TypeScript es evidencia indiscutible), mientras que Python está empezando a incluir elementos para poder incluir verificaciones de tipos.

     

Importar modulos personalizados de Pthton en Google Colab. ¿Una tarea imposible?

 

Cómo importar módulos personalizados en Google Colab

Google Colab es una plataforma en línea popular para ejecutar experimentos de ciencia de datos y aprendizaje automático. Proporciona un entorno potente y flexible para ejecutar código Python, que incluye compatibilidad con bibliotecas populares como TensorFlow, Keras y PyTorch. Sin embargo, un problema común que enfrentan muchos usuarios cuando trabajan con Colab es la importación de módulos personalizados. En esta publicación, exploraremos algunas técnicas para importar módulos personalizados en Google Colab.

Importar modulos por default en Google Colab

 Fuente: https://tinyurl.com/24syzaxv

>># Importar módulos de la biblioteca de módulos estándar


Un módulo es un script que contiene código de Pyhton. Su extención es `.py`. En los módulos se almacenan _variables_ y _funciones_ que nos permiten realizar ciertas actividades de manera automatizada.

Python cuenta con una biblioteca de módulos estándar. Algunos módulos se integran en el intérprete y estos proveen acceso a operaciones que no son parte del núcleo de Python pero que si están integrados.

**La forma en la que podemos agregar un módulo a Python es con la función `import`.** Por ejemplo, el módulo [`math`](https://docs.python.org/3.7/library/math.html#module-math), que nos permite realizar operaciones como raiz cuadrada, usar funciones trigonométricas, exponenciales, etc., se importa de la siguiente manera:

>>import math # de esta forma importamos el módulo math
 

Podemos importar solo algunas funciones de los módulos o importar todas las funciones. También podemos importar un módulo y renombrarlo para acceder a las funciones de una forma más sencilla.

>>from math import sqrt, exp # solo estamos importando las funciones raiz cuadrada y exponencial

Al importar de esta manera las funciones, si queremos usarlas, solo debemos de llamarlas con el respectivo nombre.

>>sqrt(25)

>>exp(25)


Cuando importamos un módulo con la sintaxis `import math`, para poder usar las funciones debemos llamarlas de la siguiente manera:

>>import math

>>math.sqrt(25)


**¿Qué sucede si importamos un módulo con la sintaxis `import math` y tratamos de usar una función sin antes colocar la palabra `math`?**

>>sin(25) # función sen(x)

>># ¿De qué manera se debe usar la función sen(x)? Escribe aquí tu respuesta:


Como mencionamos anteriormente, también podemos renombrar los módulos de tal forma que sean más sencillos escribirlos. La manera de hacerlo es la siguiente:

>>import math as mt # con esto renombramos el módulo math como mt. 

En general, a la palabra que utilizamos para renombrar un módulo se le denomina 'alias'.

>>mt.sqrt(25) # ahora, en lugar de escribir math.sqrt, debemos/podemos escribir mt.sqrt

 Respuesta de PPI a los interrogantes del Post:

>>sin(25)

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-16-e1fffd940751> in <cell line: 0>()
----> 1 sin(25)

NameError: name 'sin' is not defined
Al utilizar la funcion sin(x), sin importar debidamente el modulo math, se genera un error
>>import math as mt
>>mt.sin(25)
>>>-0.13235175009777303

Entradas recientes

Que dice Gemini Notebook sobre POO en Python?

PPI:   Me gustaría que al comienzo me explicaras POO sin tener en cuenta la ingenieria de confiabilidad y quisiera resolver los ejercicios e...

Entradas Populares