Clients

Estas últimas clases… resultaron muy confusas… Yo soy desarrollador en .Net y Java, y creo que el profesor en lo referente a la programación orientada a objetos y la creación de paquetes presenta muchos conceptos con muy poca explicación; por ejemplo el uso del decorador @staticmethod para indicar que una clase es estática lo introduce sin una explicación muy clara.

Platzi debería tener una opción para calificar cada clase, con esto les seria mas facil hacer seguimiento a las clases que no están funcionando o con las que la comunidad no se siente conforme.

Considero que si se realizara una explicación previa a entrar al código, como se hace en otros videos de este mismo curso, se entendería de manera más sencilla.
De igual forma si nos pusiera en pizarrón (tablet) el diseño de la solución y cómo se va a implementar, igual también ayudaría mucho en el entendimiento, ya que es este caso se salta de un archivo a otro, creando funciones sin nosotros conocer pq.

No es claro. Es muy dificil de seguir, parece que tiene mucho afan para explicar.

Es preferible una clase larga pero con buena pedagogía que esto así

Division (estructura) de nuestro programa:
<br>
👀👀👀Interface --------------> Comandos
👾👾👾Logica ---------------> Servicios
🙋🙋🙋ObjetosInteractivos --> Clientes

Esta clase parece una carrera contra el tiempo. Creo que podría tomarse un poco mas de tiempo explicando los pasos, sobre todo cuando construye las clases.

Vi que mucha gente se esta perdiendo en estas clases, primero, tranquilos, no se rindan, yo estoy igual que ustedes, recien arranco con la programación y algunos ejercicios o conceptos no me salen!

Asi que aca dejo mi aporte:

1)Repasar repasar y repasar
2)Vuelvan el video una y otra vez

Pd:Aca les dejo mi codigo, se que es una mala practica comentar todas las lineas pero quiza les pueda ayudar.

models.py:

import uuid

class Client: #Crea el objeto cliente
    def __init__(self, name, company, email, position, uid=None): #Inicializa las instancias del objeto Cliente 
        self.name = name
        self.company = company
        self.email = email
        self.position = position
        self.uid = uid or uuid.uuid4() #Si no recibe como parametro la variable "uid", devuelve el ID UUID4(), que se utiliza para generar ID'S en generral.

    def to_dict(self):
        return vars(self) #Chequea lo que regresa el metodo __dict__ y nos realiza un diccionario de nuestro objeto

    @staticmethod #Metodo estaticos dentro de nuestra clase, es un metodo que se puede ejecutar sin la necesidad de una instancia de clase
    def schema(): #No hace falta pasar por parametro SELF porque el decorador @staticmethod nos permite hacerlo.
        return ['name','company','email','position','uid'] #devuelve una lista de las variables que existen en el objeto CLIENT'

    
    '''def dict(self):  #Intentar el metodo to_dict con este metodo haber si funciona
        return vars(self)''```

services.py:

‘’‘Logica de negocio,
#Aqui vamos a guardar todo lo que signifique cada funcion, update, list, create, etc’’’

from models import Client
import csv

class ClientService:

def __init__(self, table_name):
    self.table_name = table_name

#Para no perderse aqui, es necesario que tengan bien claro los conceptos de la clase "Manejo de archivos con python"
def create_client(self, client):
with open(self.table_name, mode=‘a’) as f: #Abre el archivo en modo “a = append”, añade un cliente al archivo csv, cada vez que se crea uno
writer = csv.DictWriter(f, fieldnames=Client.schema()) #Referencia del WRITER
writer.writerow(client.to) #Escribir una nueva fila tabular dentro de nuestro archivo csv```

PD2:aclaro que recien soy principiante en esto y es por ahora mi forma de entender, me gustaria que alguien pueda corregirme si algo esta mal

No es claro, muy confuso y dificil de seguir!!!

Yo pienso que el profesor demuestra conocimientos profundos en todo momento, de temas muy complicados, al igual que a ustedes me resulta confuso pero trato de apoyame en libros al repecto e investigacion en internet, no es la idea ya que al adquirir un curso esperas que todo este claro pero, al entender las bases investigar y ensayar todo va tomando forma de a poquitos, el curso bueno, el profe conocimientos profundos y definidos, yo pondria el pero en la estructuracion del curso y propongo se sumen mas notas de apoyo escritas al curso y apoyo de herramientas como jupyter que harian mucho mas facil esto que solo videos, no hay forma de aprender sin ensayar y solo video lo hace dificil.

Para los que se pregunten el comando que el profesor usa para mostrar la estructura de archivos tiene una opcion -I donde indica que carpetas quiere ignorar. Para el caso espesifico de él esta ignorando _ _ pycache _ _, que es donde se guardan los archivos compilados por python; esta ignorando *.egg-info, que es donde se guarda la información de la instalación del programa y esta ignorando la carpeta venv, que es donde estan los archivos y carpetas relativos al ambiente virtual. Para mi caso tambien estoy ignorando la carpeta que crea vscode para que la estructura de archivos me quede más limpia y legible.
.
El comando resultante queda realmente largo para escribirlo constantemente, es recomendable guardarlo en un alias, bien sea un alias temporal para la sesion abierta del terminal o escribirlo en el archivo .bashrc que esta en el home.

El problema no esta en el profesor, ya que explica y se le entiende perfectamente; el problema radica en el contenido y estructuración del curso que presenta vacíos y confusiones entre cada clase.

Le falta estructurar las clases por que da saltos de información demasiado grandes y es complicado seguir el paso si no se tienen conocimientos de programación

Investigando un poco di con que existen classmethods y staticmethods y la diferencia me cuesta mucho entenderla. Aquí un link sobre dicha diferencia, pero está en inglés y me cuesta entenderlo con temas tan complejos.(https://stackoverflow.com/questions/136097/what-is-the-difference-between-staticmethod-and-classmethod?noredirect=1&lq=1). Apoyo 😦

Considero que la clase no estuvo a la altura de lo que pretende explicar, así que les voy a explicar lo que entendí sobre un tema que se pasó por alto. Si me equivoco en algo espero puedan corregirme:

@classmethods y @staticmethods son decoradores que se suele usar sobre las funciones de una clase.

Cuando trabajamos con clases, los métodos regulares (las funciones de toda la vida) pasan automáticamente una instancia como primer argumento (la llamamos self).

@classmethod automáticamente pasa una instancia referida a la clase como primer argumento (la llamamos cls y se comporta algo parecido a self) ejemplo:

#suponemos que estamos dentro de una clase y estamos definiendo sus métodos

@classmethod
def from_string(cls ,emp_string): #notese el cls
first, last, pay = emp_strsplit(’-’)
return cls(first,last,pay) #regreso los mismos valores que contiene el init de la clase, es como si cls emulara ser la clase

#no es requisito indispensable retornar cls, se pueden hacer otras cosas sin retornar.
#no se enrieden en los detalles del código, lo importante es el comportamiento de @classmethod y dejo link del vídeo al final para que puedan ver el ejemplo completo.

@staticmethod no pasa ninguna instancia automáticamente, casi son como los métodos regulares, pero guardan alguna conexión lógica con la clase.
Los métodos regulares necesitan usar el self para cumplir algún objetivo, @classmethod necesita el cls para cumplir algún objetivo, mientras que a @staticmethod lo vamos a usar en aquellos métodos (funciones) en los que no se requiera ni de self ni de cls. Un ejemplo es el que usa David en el código de la clase.

Este tema lo entendí gracias a: https://www.youtube.com/watch?v=rq8cL2XMM5M
Está en ingles, les sugiero que lo vean ya que seguramente explica mejor que yo el tema y van a poder ver un ejemplo completo. Y si no entiendes ingles, espero haberte ayudado con mi explicación del tema. Saludos

Se subió mucho la dificultad en estas últimas clases… al principio pensé que era lo mismo que las anteriores pero en estas últimas me han puesto a abrir el IDE y tratar de seguir el paso… Y sinceramente esto es lo que espero de un curso más avanzado, pero como sugerencia, los primeros 3 módulos los dejaría en el curso básico, que esto es una repetición práctica de lo mismo que se vio como en 3 cursos anteriores, y haber enfocado a desarrollar puntos más avanzados como los que otros compañeros comentan, si algunos como yo estamos haciendo el path de Backend con Python y Django tendrán la noción de lo que hablo…

En fin este curso tiene ya 3 años, asi que espero que conforme se vayan actualizando los cursos vayan refinando más la estructura de los cursos… Ej.

• Curso Básico… (Tipos de variables, funciones, etc… lo que se ve en los cursos de Facundo)
• Curso práctico de lo básico (Iniciar con un proyecto como se hizo en este con lo básico)
• Curso Intermedio… (Aquí ya hablar de comprehensions, clases, etc… y no repetir lo anterior)
• Curso práctico Intermedio (Modificar el proyecto inicial con los nuevos conocimientos, lo mismo que se hizo aquí)
• Curso Avanzado… (Aquí ver design patterns, arquitectura de proyectos, etc…)
• Curso de Testing…
• Cursos de Frameworks

Saludos

Creo que tendré que repasar y hacer los últimos 11 videos del curso una y otra vez jajaja.

Luego de mirar esta serie de vídeos complicados varias veces pude entender de qué va! A seguir! 😁

David Aroesti podrías anexar una descripción de que hace cada elemento del árbol de la API???, para tener mas claridad de como funciona cada scrip y módulo, dentro del sistema general

Para hacer un buen repaso de los conceptos de python es un buen curso pero de acá para adelante es mejor buscar por otros lados, ya se pierden los conceptos que se llevaban con tiempo y la curva de aprendizaje tiene saltos importantes … encima les falta explicar los errores constantes que se presentan.

Python no solo es un lenguaje orientado a objetos, sino un lenguaje formado por objetos.
Cuando creas una funcion en python con la palabra recervada “def” estas creando una variable del tipo “function” que ocupa un espacio de memoria determinado. Aunque esto suena tan trivial es muy importante para entender los decoradores.

El hecho de que esto sea así es que permite que los decoradores funcionen.

Veamos

from datetime import datetime, timedelta


def ultimo_dia_mes():
    '''
    con esta funcion obtienes el ultimo dia del mes actual
    :return: datetime
    '''
    hoy = datetime.now()
    mes = int(hoy.month)
    periodo = int(hoy.year)
    if mes == 12:
        mes = 1
        periodo += 1
    else:
        mes += 1
    return datetime(year=periodo, month=mes, day=1) - timedelta(days=1)

si escribes el nombre de una definicion en la shell de python te regresara algo como esto

>>> ultimo_dia_mes
<function ultimo_dia_mes at 0x7fed01d60668>
>>> 

indicandote el tipo y la direccion de memoria de esa definicion

>>> type(ultimo_dia_mes)
<type 'function'>
>>> 

Y como puedes ver si pides el tipo de esa definicion, python te dirá que es del tipo function. Por lo que las funciones son objetos.
Pero cuando le agregas los parentecis entonces estas llamando a un método llamado execute (no me consta en que en python 3 se llame igual) del objeto function que lo que hace es ejecutar de manera secuencial las lineas de codigo que agregaste a la definicion.

>>> ultimo_dia_mes()
datetime.datetime(2019, 3, 31, 0, 0)
>>> 

Con esto aclarado veamos los decoradores.
Los decoradores son funciones (objetos) que en su método execute (el metodo que manda a ejecutar las linea de codigo secuencial que mencioné antes) tiene como parametro otra funcion (otro objeto por cierto) esto con el objetivo de poder ejecutar código definido en el decorador y luego decidir si ejecutar el de la funcion original.

import math

# este será el decorador, veamos como se construye
def solo_numeros_positivos(funcion_matematica_original_aplicada_al):
    # funcion handler.
    # esta funcion debe tener la misma cantidad de parametros
    # que las funciones donde se va a usar el decorador
    def validar_positivo(numero):
        if not numero == 0:
            # si el numero no es cero, ejecuto la funcion original sobre el numero
            return funcion_matematica_original_aplicada_al(numero)
        else:
            # pero sino regreso un error indicando que solo acepto numeros positivos
            raise(BaseException("solo numeros positivos por favor"))


    # ahora esta funcion que acabamos de definir dentro del decorador es la que regresamos
    # pero sin los parentecis, ya que queremos regresar la definicion de la funcion
    # y no ejecutarla
    return validar_positivo


@solo_numeros_positivos
def mitad(numero):
    return numero / 2


@solo_numeros_positivos
def logaritmo(numero):
    return math.log(numero)

ahora si ejecutas mitad o logaritmo y pones de parametro “0”, entonces no se ejecutara el codigo dentro de mitad ni logaritmo sino que se ejecuatara el raise con el error de “solo numeros positivos por favor”

commands.py -> interfaz
services.py ->lógica
models.py —>objetos de interacción

Division (estructura) de nuestro programa:

Me parece que la informacion del curso es excelente. Lo que no me gusta realmente, es que en este punto de los modulos que es lo que piden para contratarte, todo se lo esta sacando de la nada… de la manga sin explicar porque, ciertamente yo puedo investigar y leer, pero las dudas que se me generaran a raiz de que no este explicado en la clase, quita semanas de valioso tiempo cuando quieres y necesitas empezas a trabajar. Recordemos que la oferta de Platzi no es didactica, hablamos de conseguir tu primer trabajo en tech y no solo pasar el rato, Esta es la parte mas compleja que deberia estar explicada para ninos de 3 anios y todo esta injustificado, solo pasa y ya… asi no se puede aprobar una prueba tecnica. La idea de pagar platzi es que todo este explicado aqui, si necesito ir a google a aclarar todo, ya no tiene sentido y eso que yo puedo leer en ingles… me imagino quienes no

Avanzo algo rapido

• Interface
• Lógica de negocio.
• Objetos sobre los cuales estamos actuando.

Venia muy bien, pero desde la clase 38 parece que hablara en otro idioma. El curso dio un salto muy grande y ya no se puede seguir el paso del profesor.

Me encantó la clase! Pero reconozco que para entender lo que el profesoe hizo hasta este punto necesite recurrir a buscar información sobre conceptos que no fueron peofundizados en clases anteriores. Me frustré en varias ocasiones: manejo de archivos, decoradores, utilización de entornos virtuales y como hacerlos funcionar, interpretar el código de click y el código de setup y porqué todo funciona como funciona… pero aprendí.

Muchas quejas de los compañeros, tampoco soy experto, pero se supone que se debió pasar por el curso de Anahí de OOP, o otros más que hay. Lo único que hizo el profe fue estructurar los módulos y lo que era necesario explicar lo hacía. Como todo, es bueno mirar la ayuda y documentación. Lo que si consideró que le hizo falta fue decir a donde vamos a llegar con todo esto y no es la primera vez que les pasa en los cursos de platzi.

Excelente profe! ojala de mas cursos!!! y muy completo el curso practico!!!

gracias Platzi!!!

AAAh. ! …Y de las consultas que he hecho, no he rebido nunca respuesta.
Solo veo mensajes de hace años y muy indexados por fecha.
lo mas actual deberia aparecer al principio.

Tratando de entender, hay ciertas enseñanzas que no se de que manga las sacan, provoca impaciencia que te digan copia y pega sin que eso tenga sentido.
Bueno …sigo adelante…! he avanzado hasta acá, con muchas horas de investigación de por temas muy poco explicados. Pero este curso no es en línea, y hacer consultas no es opción…no hay nadie al otro lado para responder en línea … frustrante … eso falta en este curso HELP ON LINE…! … en este curso y en el de Selenium, es dificil aprender cuando el profesor te van repitiendo lo que escribe. Prefiero que me pasen las líneas de codigo hechas, pero que el profesor se dedique a explicarlas …eso ayuda a aprender very fast.
Quiero que me enseñen a pescar …no que me den pescado.
Con todo respeto, como ustedes lo indican expreso mi parecer.

def to_dict(self): ''' vars return __dict__ ''' return vars(self) vars permite retornar una representación en diccionario del objeto

Les comparto LA EXPLICACION a “mimismo” del objetivo del codigo y posterior el codigo comentado con mas explicaiones. Ojala ayude.
.
Primeramente el objetivo de este programa que estamos escribiendo es crear una interfaz de usuario en linea de comando mas interactiva e intuitiva(hasta las posibilidades de una linea de comandos) que la que ya realizamos anteriormente, en si estamos volviendo hacer de otra manera.
.
Si has usado alguna interfaz de linea de comando habrás notado que usa “comandos” (valga la redundancia) para realizar acciones como eliminar, crear, elegir, modificar, acceso a base de datos etc. y que cada comando tiene su nombre, esos comandos son los que intentamos crear mediante el modulo “click” que nos permite “crear” y “personalizar” los comandos que usaremos y darles funcionalidad de una manera mas simple. Es decir que estamos creando nuestro programa de linea de comandos para administrar nuestras listas de clientes “Platzi ventas”. El objetivo es que este programa sea mas “amigable” para un usuario comun que usar directamente la terminal.
.
Te anexo mi codigo comentado donde puse algunas anotaciones de lo que estamos haciendo, me ayudo para comprender lo que estamos realizando.
.
archivo commands:

import click

"""modificamos los comandos que usaremos dentro del grupo clientes.
   Estamos creando una interfaz de usuario, recreando el programa
   de "Platzi ventas" que programamos anteriormente pero ahora en
   una interfas de linea de comandos, basada en texto.
"""


# para convertir las funciones siguientes en comandos de click usamos los decoradores
@click.group() # este decorador hace a la funcion "clients" otro decorador. al que agregaremos comandos
def clients():
    """Manage the clients lifecycle"""
    pass


@clients.command()  #con este decorador estamos diciendo que la funcion("create") es un comando de nuestra funcion "clients" (grupo de comandos)
@click.pass_context  #le pasamos el contexto que generamos anteriormente en el archivo "pv.py", haremos lo mismo para las otras funciones.
def create(ctx, name, company, email, position):  # creamos nuestros contactos basicos
    """Creates a new client"""
    pass


@clients.command()
@click.pass_context
def list(ctx):
    """List all clients"""
    pass


@clients.command()
@click.pass_context
def update(ctx, client_uid):
    """Update a client"""
    pass


@clients.command()
@click.pass_context
def delete(ctx, client_uid):
    """Delete a client"""
    pass


all = clients  # esto crea un alias de todos los comandos creados aqui.

archivo pv:

import click

from clients import commands as clients_commands  # importamos los comandos de la funcion "clients" del archivo "commands.py", como si se llamaran "clients_commands"


@click.group() # con este decorador le decimos a click que es nuetro punto de entrada
@click.pass_context # nos da un objeto contexto, lo agregaremos a la funcion como "ctx"
def cli(ctx):
    ctx.obj = {} # este objeto contexto lo inicializamos como un diccionario vacio


cli.add_command(clients_commands.all) # añadimos a la funcion "cli" los comandos establecidos en el archivo "commands.py"

archivo models

import uuid  #modulo para crear "id" unicas automaticamente

class Client:
    def __init__(self, name, company, email, position, uid = None):
        self.name = name
        self.company = company
        self.email = email
        self.position = position
        self.uid = uid or uuid.uuid4()  # tomamos el uid que se nos proporcione, si no se nos proporciona generamos uno mediante el modulo uuid, uuid4 es un estandar en la industria para generar id unicos. los id son nesesarios en una base de datos como indentificadores

        def to_dict(self):
            return vars(self)  # la funcion global "vars" nos permite acceder a una representacion en diccionario de nuestro objeto que hemos construido(la clase Client) ya que para poder guardarlo en formato "csv" es necesario que sea un diccionario.

        @staticmethod # este decorador permite tener una funcion sin que sea parte "implicita" de la clase y no necesita recibir un primer argumento implicito como "self"
        def schema(): # esta funcion nos ayuda a establecer lo que ira en la cabecera de nuestra tabla con los datos de los clientes, solo nos ayudara a crear la cabecera de la tabla de clientes.
            return ['name', 'company', 'email', 'position', 'uid']

archivo services:

import csv  # modulo para manejar archivos csv
from clients.models import Client  # con esto importamos la clase Client(con el formato que tendran nuestros clientes y la cabecera de tabla) que usaremos para crear nuestros clientes. esto se importa del archivo "models.py" de la carpeta "clients"

class ClientService:

    def __init__(self, table_name):  # creamos el nombre de nuestra tabla de clientes, nuestro archivo csv
        self.table_name = table_name
    
    def create_client(self, client):  #el parametro "client" al parecer sera dado con posterioridad
        with open(self.table_name, mode = 'a') as f: # mode = "a" significa modo append, añadiremos nuevas filas conforme lo nesecitemos
            writer = csv.DictWriter(f, fieldnames = Client.schema()) # escribiremos en nuestro archivo "f", definimos las comlumnas de nuestra tabla con "fieldnames" que tomamos de la clase "Client" del metodo estatico "schema" creada en el archivo "models" y que importamos al inicio de este archivo
            writer.writerow(client.to_dict())  # escribimos en el archivo una fila, "DictWriter" necesita diccionarios por lo que el parametro "client" lo pasamos a "to_dict"(funcion que creamos en el archivo models para convetir strings a diccionarios) y lo convertimos en diccionario.

el archivo setup es como el instalador de todo esto.

creo que este curso esta mas orientado a los que siguen el path de Desarollo Backend con Python y Django, si sigues el path la verdad cuando llegas a este punto todo se ve de manera clara y no tienes tantas complicaciones para entender que está pasando no pierdan el animo

Para entender bien los diferentes tipos de métodos en python: https://blog.nearsoftjobs.com/tipos-de-métodos-en-python-cls-vs-self-d6da1e08efa8

Este David Aroesti es muy crack pero en estos cursos ha estado mostrando varios nuevos conceptos sin ver “qué hay debajo del cofre” como dice él

Los metodos estáticos no reciben el parametro sel fporque no necesitan una instancia, no depende de la clase, podemos utilizar este método sin haber inicializado la clase en una variable.
Interesting

Nuestro esquema es el nombre que tendrán nuestras columnas a la hora de convertir los datos en csv y viceversa

Nuestra lógica de negocio, sencillamente puede ir en una clase.

No te olvides de self, xD

UUID

UUID(Universal Unique IDentifier) es un módulo que nos brinda objetos, funciones y una clase UUID que cumplen con unos parametros preestablecidos,

Cuando queremos usar ID únicas se suele usar las funciones uuid1() o uuid4()

• uuid1() “crea un ID único relacionado a la dirección de red, es por ello que si se utiliza en algo público puede comprometer la seguridad.”

• uuid4() “crea un UUID aleatorio.”

acá la documentación completa de UUID.

vars() function

La función vars() regresa el atributo dict de un objeto.
En la clase se usa para poder convertir en diccionario nuestro objeto client y de esta forma poder guardarlo como un csv.

Métodos de clase y métodos estáticos.

Cuando usamos regular methods, pasamos la instancia como el primer argumento, es por ello que utilizamos el self.

Cuando usamos @classmethod, pasamos primero la clase como primer argumento, escribiendo cls.

Cuando usamos @staticmethod, no pasamos ninguna automáticamente, funcionan y se comportan como funciones regulares pero las incluimos en las clases porque tienen una conexión lógica con la clase.

Comparto un vídeo con más de información y ejemplos de como funciona @classmethod y @staticmethod haz clic aquí está en inglés.

Excelente

yo estoy trabajando con linux ubuntu y no tenia tree instalado.
Lo solucione de la siguiente forma:

sudo apt-get install tree

y luego actualice

sudo apt-get update

se corta el video

A mi se me hace que esta apenas

En vez de crear el metodo to_dict() pude usarse el metodo dict()?

Division (estructura) de nuestro programa:

Interface --------------> Comandos
Logica ---------------> Servicios
ObjetosInteractivos --> Clientes

import uuid: Generamos ids únicos

De verdad programando se ve que la rompe el profesor!!
Pero explicando muchas vecs entre mas complejo es los temas menos pronfudiza para explicar!
A veces solo dice aquI vamos a escribir este cOdigo pero no explica el por quE ni para quE!! No cuadra mucha estar pagando y solo ver como programa el profesor!
Una cosa es pogramar y otra cosa ensenar a programar!
Una critica constructiva es profundizar en cada tema y detallar porque muchos estamos pagando es para eso!

Así ni dan ganas de terminar el curso

Existe un modo de append para los archivos, de modo que no tenemos que copiar todo agregar algo nuevo y luego hacer un nuevo archivo a partir de ahí, sino que simplemente agregamos al archivo existente.

Existe el decorador @staticmethod, para declarar un método sin necresidad de una instancia de clase.

La función global vars, nos permite ingresar a nuestro propio método dunder dict, dejándonos acceder a una representación de nuestro objeto en diccionario, todo esto, debido a que necesitamos iterar y luego guardar nuestro cliente.

Existe un módulo que se llama uuid, para generar id con la sencuencia que queramos, normalmente el estándar es de 4, debido a que es fácil su autenticidad

Nuestras aplicaciones, se dividen las interfaces (son las que interactuan con el humano), por lo que siempre esa parte se separa, de forma que toda interfaz queda en su propio espacio. Luego tenemos la lógica específica de nuestro programa, en la que nos enfocamos en el funcionamiento deseado de la aplicación, luego en el otro tercio se encuentra la abstracción, que son los objetos sobre los cuáles interactuamos

Los end points son nuestra interfaz en las API's

https://platzi.com/clases/1378-python-practico/14183-clients/?time=119. Ha descrito con sus palabras el Model View Controller. Interesante.

y si no tenemos un sistema UNIX qué. jajajajaja eso solo funciona en UNIX. empieza el calvario a partir de aquí, de todas formas seguiré atentamente el código, pero no me va a funcionar nunca.

VARS(): La función vars() adolece de una restricción importante: sólo funciona cuando se aplica sobre un objeto que, necesariamente, tiene el atributo diccionario, esto es, dispone del método especial dict y esto es precisamente lo que devuelve, igual que las funciones locals() y globals(), un objeto diccionario.

De la frustracion pase a la furia, a la mierda el curso y el profesor, espero mejore en el futuro, por mi parte vere si rescato algo de youtube. Disculpen pero necesitaba hacer este comentario.

estupenda la case, sigamos aprendiendo