Trucos y consejos

Introducción

En las dos primeras partes de este libro, descubrió Python y aprendió a copiar y reproducir código Python.

Esta tercera y última parte está mucho menos estructurada que las demás. Se trata más de mostrar determinados puntos y posibilidades del lenguaje, de forma creciente.

Al principio, veremos algunos consejos y trucos, y algunas nociones ya mencionadas, pero presentadas con más profundidad. También encontrará ejemplos, algunos de los cuales son deliberadamente lúdicos y didácticos, mientras que otros tienen una aplicación muy real y podrían serle de utilidad.

Los dos últimos capítulos tratan sobre herramientas y software escritos en Python.

El capítulo Ir más lejos con Python, habla sobre algunas herramientas de Python que se pueden usar, con una pequeña inversión.

Mientras que el último capítulo evoca software escrito en Python, pero de una dimensión superior, donde es necesario invertir un poco más para beneficiarse de todo lo que ofrece. Sin embargo, puede estar seguro de que el juego vale la pena, y de que algunos desarrolladores realmente han aportado algo, al menos durante un tiempo, a la informática en general. Sería una pena no aprovechar este trabajo excepcional.

Y aunque solo se trate de descubrir de lo que son capaces estos productos, al hacerlo, mostrará respeto...

Adaptar la función copiar/pegar de una hoja de cálculo para una wiki

Es un pequeño truco, que puede ser útil y que permite comprender ciertas cosas. 

Cuando desea copiar/pegar una selección de celdas de una hoja de cálculo en una wiki, termina con un tabulador como separador y tiene que reformatear la tabla en modo wiki, lo que puede ser tedioso.

Pero gracias a Python, es posible modificar el contenido del clipboard (portapapeles).

El portapapeles, en Linux, no es algo obvio y, por ejemplo, para que funcione, ha sido necesario instalar una herramienta llamada xclip (sudo apt install xclip).

También debe instalar el módulo clipboard con ’pip install clipboard’.

¿Como se usa?

Solo tiene que seleccionar tus datos en la hoja de cálculo y ejecutar un pequeño script.

Luego tiene que copiar/pegar en la wiki… es mágico.

Copiar desde la hoja de cálculo -> Ejecutar el script de Python -> Pegar en la wiki.

A continuación se muestra un ejemplo del resultado:

===> Sin el script python  
Columna 1    Columna 2  
100    200  
101    201  
  
===> Con el script python  
^Columna 1    ^Columna 2    ^  
|100    |200    |  
|101    |201    |  
|       | 

El script...

Unpacking con Python ()

Esto tiene más parte de sintáctico que de un verdadero "truco y consejo", pero puede ser muy práctico.

Tenga cuidado, este es el tipo de sintaxis que no es necesariamente obvia y por lo tanto, existe el riesgo de pérdida de visibilidad. Entonces hay que comentar este tipo de sintaxis.

En los primeros capítulos donde descubrimos el operador de asignación ’=’, también descubrimos la posibilidad de asignar varias variables:

>>> a = b = c = 1  
>>> print(a,b,c)  
1 1 1  
  
>>> a,b,c = 1,2,3  
>>> print(a,b,c)  
1 2 3  

Pero hay algo aún mejor con el operador ’*’.

También es posible asignar una variable y/o una lista.

A continuación se muestran algunos ejemplos:

>>> lista = list(range(0,9))  
>>> lista  
[0, 1, 2, 3, 4, 5, 6, 7, 8]  
  
>>> *x, y, z = lista  
  
>>> print("x=",x," y=",y, " z=",z)  
x= [0, 1, 2, 3, 4, 5, 6]  y= 7  z= 8  
  
>>> x, *y, z = lista  
  
>>> print("x=",x," y=",y, " z=",z)  
x= 0  y= [1, 2, 3, 4, 5, 6, 7]  z= 8  
  
>>> x,y,*z = lista  
  ...

El guion bajo y Python

El guion bajo es un carácter de usos múltiples en el lenguaje Python.

A continuación se mostrarán algunos trucos que se pueden encontrar en el código. 

>>> [ x for x in range(0,5)]  
[0, 1, 2, 3, 4]  
>>> _  
4  
>>> _ * 2  
8 

>>> primero, _ , ultimo   = (1,2,3)  
>>> print(primero, ultimo)  
1 3 

>>> primero,*_, ultimo = list(range(0,10))  
>>> print(primero, ultimo)  
0 9  
>>> _  
[1, 2, 3, 4, 5, 6, 7, 8] 

>>> for _ in range(5):  
...   print(_)  
...  
0  
1  
2  
3  
4 

>>> 1024*1024*1024*1024  
1099511627776  
  
>>> 1_099_511_627_776  
1099511627776  
  
>>> 1_099_511_627_776 / 1024 / 1024 / 1024  ...

Estresar las CPU y medir el tiempo del código

A continuación se mostrarán dos trucos en uno.

El primero es bastante simple, porque el objetivo es estresar a una o más CPU.

Es bastante fácil de lograr: basta llamar al cálculo en coma flotante dentro de un bucle lo suficientemente grande, como para medirlo.

A continuación se muestra un pequeño ejemplo:

# archivo: timing/test_cpu1.py  
  
import time  
  
inicio = time.time()  
  
num_mul = 50_000_000     #alrededor de 15s  
data = range(num_mul)  
numero = 1  
  
for i in data:  
   numero *= 1.0000001  
  
fin = time.time()  
  
print("Resultado = {}".format(numero))  
print("Tiempo = {}".format(fin - inicio)) 

Un bucle de 50.000.000 (50 millones) dura unos 15 s en nuestra máquina Se debe adaptar en función de las necesidades.

Y eso "estresa" a un procesador.

CPU 100%

El segundo truco es una versión mejorada de la clase estudiada con los administradores de contexto: medir el tiempo de una función, pero en algunos casos, poder medir además un tiempo intermedio.

El principio es simple: para tener un administrador de contexto, se necesita una clase que implemente las funciones "especiales" __enter__()...

Crear un decorador (logger interne)

Como vimos en un capítulo anterior, en realidad el decorador no es más que una función que se ejecuta antes que otra función.

A partir de ahí, puede ser muy útil para depurar algunos scripts, ya que es suficiente con generar el log cada vez que se llama a la función.

A continuación se muestra un ejemplo de script:

#archivo: log/log1.py  
  
def log(function):  
   def funcion_interna( *args, **kwargs):  
       print("============ LOG ============")  
       print("Función: {}".format(function.__name__))  
       print("Argumento enviado: ")  
       print("  args   : {} ".format(args))  
       print("  kwargs : {} ".format(kwargs))  
       print("================================")  
       return( function(*args, **kwargs) )  
   return funcion_interna  
  
  
@log  
def test1( a, b ,c):  
   print(a, b ,c)  
  
@log  
def test2(a="?", b="?" , c="?"):  
   print(a,b,c)  ...

Escribir código correctamente en Python (PEP8)

Python es un lenguaje bastante legible. Hace unos años, el autor probó con informáticos que no estaban familiarizados con el lenguaje, la lectura de código Python y casi todos pensaron que entendían el significado del script.

Pero a pesar de esto, Guido Van Rossum y algunos otros programadores recomiendan un estilo de escritura para este lenguaje.

De ahí nació el PEP8: https://www.python.org/dev/peps/pep-0008/

PEP (Python Enhancement Proposals) es una propuesta de mejora del lenguaje.

El punto de entrada se llama PEP 0: https://www.python.org/dev/peps/

No es obligatorio escribir código de esta manera, se trata sobre todo de recomendaciones.

Y para saber si su estilo de codificación está lejos de la "propuesta" o "norma" de estilo, existe una utilidad llamada pep8, que solo hay que ejecutar en un script.

A continuación se muestra un ejemplo del resultado en un script que veremos en el próximo capítulo:

$ pep8 --ignore=E201,E202 python_batalla.py --statistics  
  
python_batalla.py:6:80: E501 line too long (120 > 79 characters)  
python_batalla.py:8:80: E501 line too long (87 > 79 characters)  
python_batalla.py:16:45: E211 whitespace before '('  
python_batalla.py:28:1: E265 block comment should start with '# '  
python_batalla.py:53:5:...