Context managers

Otro gran ejemplo de context managers (sin caer en el razonamiento circular usando “open” para crean un “custom_open”)
es el verlo como una implementacion de tareas de shell, pero en python (imaginate escribiendo el “setup.py” de un server linux)

Han notado como es muy sencillo escribir en shell:

cd /path/to/project
coolShellCommand -xyz
cd -

Pero en python se necesita implementar algo como esto:

cwd = os.getcwd()

try:
	os.chdir('path/to/project')
	os.system('coolShellCommand -xyz')
finally:
	os.chdir(cwd)

Lo cual se ve bastente feo y desordenado, seria genial escribir algo como:

with os.chdir('path/to/project/'):
	os.system('coolShellCommand -xyz')

Pero no existe, asi que creemoslo nosotros:

class cdContextMgr(ob­jec­t):
    def __init__(­self, new_dir):
        self­.new_dir = new_dir
        self­.old_dir = None

    def __en­ter__(­self):
        self­.old_dir = os­.getcwd()
        os­.chdir(­self.new_dir)

    def __ex­it__(­self, *_):
        os­.chdir(­self.old_dir)

y asi podemos utilizar:

with cdContextMgr('/path/to/project')
	os.system('coolShellCommand -xyz')

Esto hace lo mismo que al principio, nos evitamos duplicar codigo y aprendemos sobre conext managers

Python esta lleno de trucos que casi parecen mágia.

Hola estimado David (@jdaroesti), me encanta la forma en la que explicas y enseñas, desde el curso pasado soy tu fan.
Sin embargo encontré en el presente artículo algo que podría mejorar:

En el primer ejemplo sobre el uso de with pegaste with con open, lo que ocasionará en la práctica un error de sintaxis.

withopen(‘some_file.txt’) as f:
    lines = f.readlines()

Siento que fue un error de dedo, pero que podría confundir a las personas que comienzan con el lenguaje.

La forma correcta del primer ejemplo sería:

with open(‘some_file.txt’) as f:
    lines = f.readlines()

El mismo detalle ocurre en el ejemplo siguiente en la línea:

classCustomOpen(object):def__init__(self, filename):

Lo correcto sería:

class CustomOpen(object):def__init__(self, filename):

Ojalá no me vea muy chocoso con éste comentario, pero siento que tu calidad como profesional de python, es muy alta y éste pequeño error podría quitar coherencia a tu imagen.

Excelente curso, ojalá fueras mentor de otros cursos de programación como javascript.

Saludos.

creo que comprendi, tengo que practicarlo mas

from contextlib import contextmanager

class CustomOpen(object):
	def __init__(self, filename):
		self.file = open(filename)

	def __enter__(self):
		return self.file

	def __exit__(self, ctx_type, ctx_value, ctx_traceback):
		self.file.close()


def read_file(filename):
	with CustomOpen(filename) as f:
		contents = f.read()
	return contents


@contextmanager
def custom_open(filename):
	f = open(filename)
	try:
		yield f
	finally:
		f.close()


if __name__ == '__main__':
	## custom = CustomOpen('operaciones_con_listas.py')
	custom_open('operaciones_con_listas.py')
	print(read_file('operaciones_con_listas.py'))
	print('-'*30)
	```

me gustó mucho esta información… de hecho siento que por fin voy entendiendo como funciona el lenguaje por dentro… animo a todos a seguir aprendiendo 😄

En palabras para mortales, los contextos son una función decoradora que ayuda a ejecutar código antes y después de código que les pasemos.

En otras palabras, el protocolo de gestor de contextos definidos en el PEP 343 permite la extracción de la parte aburrida de la estructura try…except…finally en una clase separada manteniendo solo el bloque de interés do_something.

Primero se llama al método enter. Puede devolver un valor que será asignado a var. La parte as es opcional: si no está presente, el valor devuelto por enter será ignorado.
El bloque de código bajo with se ejecutará. Como si fueran condiciones try. Se podrá ejecutar con éxito hasta el final o, si algo falla, puede break, continue` o return o lanzar una excepción. Pase lo que pase, una vez que el bloque ha finalizado, se producirá una llamada al método exit. Si se lanzó una excepción, la información se manda a exit, el cual se describe en la siguiente subsección. En el caso normal, las excepciones podrían ser ignoradas como si fueran una condición finally y serían relanzadas después de que finalice exit.

Excelente ejemplo

Esta clase me voló la cabeza. Ahora entiendo cómo funciona el with perfectamente.

Excelente info

En que otros ambitos o casos podemos usar el context manager

Genial, excelente información.

Los métodos init, enter y exit los entendí como los React lifecycles jajaa

Las 2 ultimas clases del módulo muy vagas en información pero son conceptos de python muy interesantes y geniales. Gracias a la comunidad por los recursos adicionales 🤠

se explica en algún momento de este curso o del curso de python el uso de yield?

Estos cursos de hace años eran como “haz el curso en max 50 clases que contenga todos estos temas” Empiezan bien y terminan de afán.

sigamos aprendiendo

Excelente lectura realmente la entendi a la perfeccion.