python

  import sys
  # Lo pongo en una línea porque no es separable conceptualmente
  sys.path.append('common/plugins'); import display

  # Cuando importamos código de otras librerías, podemos hacer sin problema
  from module import function
  # Pero cuando estamos trabajando con módulos propios, conviene importarlos siempre
  # con el nombre del módulo
  import module
  foo = module.function()
  # Así cuando cambiamos module, podemos recargarlo sin tener que reiniciar IPython:
  from importlib import reload
  reload(module)

from itertools import takewhile

def f(n):
    for i in range(n):
        yield i
        print(i)
def g():
    f1 = list(f(1))
    f2 = list(f(2))
    f3 = list(f(3))
    yield f3
    yield f2
    yield f1

list(takewhile(lambda x: len(x)>2, g()))

pip install tk PyQt6 # Estos funcionan con pip

import matplotlib.pyplot as plt
plt.ion() # Interactive mode ON
plt.rc('text', usetex=True) # Latex rendering
plt.minorticks_on() # Needs to be set before calling plot.grid()
plt.grid(True, which='both')
plt.tick_params(axis='both', which='major', labelsize=20) # Plot tick size
plt.tight_layout() # If xlabel gets cut off
plt.xlabel('$\\lambda \\mathrm{ (nm)}$')
plt.xlabel('$\\lambda \\text{ (nm)}$') # PETA fuertemente
plt.xlabel('$\\lambda $\\text{ (nm)}') # Probar
plt.title(r'Entrop\'ia') # renders to Entropía
plt.title(r"$Regresi\'on$") # Renders to Regresión
# Linear regression
slope, intercept, r, prob2, see = scipy.stats.linregress(x, y)
mx = x.mean()
sx2 = ((x-mx)**2).sum()
sd_intercept = see * np.sqrt(1./len(x) + mx*mx/sx2)
sd_slope = see * np.sqrt(1./sx2)

from matplotlib.animation import FuncAnimation
from matplotlib.animation import writers
Writer = writers['ffmpeg']
Writer = writers['ffmpeg_file'] # Para exportar muchos frames y no comerse la ram
duration = 120 # En segundos
fps = t_gridnum/duration if t_gridnum/duration > 25.0 else 25.0 # Mínimo 25fps
writer = Writer(fps=fps)
ani = FuncAnimation(fig, animate, init_func=init, frames=np.arange(len(times)), repeat=False, cache_frame_data=False)
# Importante el cache_frame_data para mayor velocidad con vídeos de muchos frames

  import json
  from pprint import pprint
  # j = json.loads(...)
  with open('Almost.json', 'w') as f:
      pprint(j, f)

  cat Almost.json | sed -e "s/'/\"/g" | sed -Ez 's/"\n[ ]*\"//g' | sed "s/None/null/g" | sed "s/False/false/g" | sed "s/True/true/g" > Full.json

  from glob import glob
  files = glob("/path/to/files/**/*.ext", recursive=True) # Con recursive=True matchea también /path/to/files/*.ext

import pytz
import datetime
date_naive_in_local_tz = datetime.datetime.now()
date_naive_in_utc = datetime.datetime.utcnow()
local_tz = pytz.timezone("America/Bogota")
# WHYYYYYY????
date_utc = local_tz.localize(date_naive_in_local_tz).astimezone(pytz.utc)
date_local = date_naive_in_utc.replace(tzinfo=pytz.utc).astimezone(local_tz)
date_utc_naive = date_utc.replace(tzinfo=None)
date_local_naive = date_local.replace(tzinfo=None)

  # Cuando esto da el siguiente error:
  (Pdb) node.read_value()
  RuntimeWarning: coroutine 'Node.read_value' was never awaited
  # Hay que ejecutarlo así:
  (Pdb) async def a(node): return await node.read_value()
  asyncio.run(a(node))
  (Pdb) asyncio.run(a(node))

  from pdb import set_trace
  from IPython import embed         # Sin colores, deja la terminal bien
  from IPython import start_ipython # Con colores, deja la terminal mal al salir
  .
  .
  .
  breakpoint(header=embed())  # Python 3.7+ en vez de set_trace
                              # https://docs.python.org/3/library/functions.html#breakpoint

# NO FUNCIONA BIEN? Creo que te imprime desde donde estás el traceback, no desde el error: import traceback; print("".join(traceback.format_stack()))
# Estas sí que funcionan
import traceback; import sys; traceback.print_exc(); traceback.print_exception(*sys.exc_info())

import sys
import traceback

try:
    raise TypeError("Oups!")
except Exception as err:
    try:
        raise TypeError("Again ??")
    except:
        pass

    # Esta imprime el traceback desde donde estás, no el error
    print("".join(traceback.format_stack()))

    # Esta llega sólamente hasta el raise, no te muestra el error como tal (por ejemplo si el error es una plantilla, sabes qué valores toman los datos)
    traceback.print_tb(err.__traceback__)
    print(err)
    traceback.print_exc()
    traceback.print_exception(*sys.exc_info())

from IPython import get_ipython
ipython = get_ipython()
ipython.magic("tb Verbose")

  def transpose(M): return list(map(list, zip(*M)))
  def dot(M, v): return [sum([m*x for m, x in zip(row, v)]) for row in M]

  In : [i for i in range(20) if i % 3 > 0] # Condicionales
  Out: [1, 2, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17, 19]

  In : [(i, j) for i in range(2) for j in range(3)] # Dobles índices
  Out: [1, 2, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17, 19]
  In : [val if val % 2 else -val for val in range(20) if val % 3]
  Out: [1, -2, -4, 5, 7, -8, -10, 11, 13, -14, -16, 17, 19]
  In : {a % 3 for a in range(1000)} # set filtra valores únicos
  Out: {0, 1, 2}
  In : {n:n**2 for n in range(6)} # diccionario
  Out: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
  In : (n**2 for n in range(12)) # crea un generador (iterador)
  Out: <generator object <genexpr> at 0x7f92cc317138>

{(k if not np.isnan(v) else k + "_nan"): (v if not np.isnan(v) else None) for k, v in sample_dictionary.items()}
{k: (v if not np.isnan(v) else None) for k, v in sample_dictionary.items()}

  # Iterar sobre lista y con índice al mismo tiempo:
  for index, element in enumerate(object[, start=0]):
  # Iterar sobre varias listas a la vez:
  for x1, x2, ..., xN in zip(list1, list2, ..., listN):
  # Combinando las dos:
  for index, elementlist in enumerate(zip(list1, list2, ... listN)):

  from collections import namedtuple
  Features = namedtuple('Features', ['age', 'gender', 'name'])
  row = Features(age=22, gender='male', name='Alex')
  # row.age, row.gender, row.name

  from collections import Counter
  ages = [22, 22, 25, 25, 30, 24, 26, 24, 35, 45, 52, 22, 22, 22, 25, 16, 11, 15, 40, 30]
  value_counts = Counter(ages)
  import numpy as np
  np.histogram(ages, bins=np.max(ages)-np.min(ages)) # Es más eficiente para len(ages) >~ 1000

  f'{a:1.2f}+{b:1.2f}j'
  f'{a=}' # En python 3.8, es equivalente a poner f'a={a}'

  from operator import methodcaller
  map(methodcaller('some_method'), some_object))

  hello_world = lambda x: (
      [print("Hello world!"),
      globals().update({'var':3+2}), # Para crear variables
      print("Your name is "+x)]
  )[-1]
  hello_world("Julian")

  # Nuevo en python 3.8
  func = lambda x: (
      # Se puede asignar con :=
      # Las variables creadas tienen ámbito local
      y := 0, (
          y := y + i for i in range(0, x)),
      y)[-1]
  y = func(101)
  print(y) # 5050

  mydict.get('key', default_value) # Devuelve mydict['key'] si existe, y si no, default_value
  mydict.setdefault('key', default_value) # Si 'key' está vacía, crea una nueva entrada con default_value

  mydict_inv = dict(map(reversed, mydict.items()))

  value = {
          'a': 1,
          'b': 2,
          'c': 3,
          .
          .
          .
          }.get(x, default_value)

  # De nuevo en python 3.8 podemos hacer asignaciones
  value = {'a': 7,
  'b': 6 if True else 0,
  'c': [y :=0, [y := y+x for x in range(0, 101)]][-1][-1]
  }.get('c', 0)
  print(value) # 5050

  ab = {**a, **b}
  # Si tienen una clave común, prevalece el valor de b

  # {a[0]:b[0], a[1]:b[1], a[2]:b[2], ..., a[n]:b[n]}
  dict(zip(a, b))

  def myfunc(x, y, z):
      print(x, y, z)
  tuple_vec = (1, 0, 1)
  dict_vec = {'x': 1, 'y': 0, 'z': 1}
  myfunc(*tuple_vec) # 1, 0, 1
  myfunc(**dict_vec) # 1, 0, 1

  # Functions are first-class citizens in Python:
  # Functions can be passed as arguments to other functions,
  # returned as values from other functions, and
  # assigned to variables and stored in data structures.

  import sys
  from importlib import reload
  if sys.modules.get('module') is not None:
      reload(sys.modules['module'])
  from module import function

  mylist.sort() # Modifica inplace
  mysortedlist = sorted(mylist) # Devuelve una copia ordenada