"""
Métodos de instancia
   El primer método en MyClass, llamado método, es un método de instancia 
   regular. Ese es el tipo de método básico y sencillo que utilizará la 
   mayor parte del tiempo. Puede ver que el método toma un parámetro, 
   self, que apunta a una instancia de MyClass cuando se llama al método 
   (pero, por supuesto, los métodos de instancia pueden aceptar más de 
   un parámetro).

   A través del parámetro self, los métodos de instancia pueden acceder 
   libremente a atributos y otros métodos en el mismo objeto. Esto les 
   da mucho poder cuando se trata de modificar el estado de un objeto.

   No solo pueden modificar el estado del objeto, los métodos de instancia 
   también pueden acceder a la clase misma a través del atributo self 
   .__ class__. Esto significa que los métodos de instancia también 
   pueden modificar el estado de la clase.

Métodos de clase
   Comparemos eso con el segundo método, MyClass.classmethod. Marqué 
   este método con un decorador @classmethod para marcarlo como un método 
   de clase.

   En lugar de aceptar un parámetro self, los métodos de clase toman un 
   parámetro cls que apunta a la clase, y no a la instancia del objeto, 
   cuando se llama al método.

   Debido a que el método de clase solo tiene acceso a este argumento cls, 
   no puede modificar el estado de la instancia del objeto. Eso requeriría 
   acceso a uno mismo. Sin embargo, los métodos de clase aún pueden 
   modificar el estado de la clase que se aplica a todas las instancias 
   de la clase.

Métodos estáticos
   El tercer método, MyClass.staticmethod se marcó con un decorador 
   @staticmethod para marcarlo como un método estático.

   Este tipo de método no toma un parámetro self ni cls (pero, por supuesto,
   es libre de aceptar un número arbitrario de otros parámetros).

   Por lo tanto, un método estático no puede modificar el estado del 
   objeto ni el estado de la clase. Los métodos estáticos están restringidos 
   en cuanto a los datos a los que pueden acceder, y son principalmente 
   una forma de asignar un espacio de nombres a sus métodos.

"""


class MyClass:
    def method(self):
        return "instance method called", self

    @classmethod
    def classmethod(cls):
        return "class method called", cls

    @staticmethod
    def staticmethod():
        return "static method called"


obj = MyClass()
print(obj.method())
print(MyClass.method(obj))
print(obj.classmethod())
print(obj.staticmethod())


print(MyClass.classmethod())

print(MyClass.staticmethod())

print(MyClass.method("dd"))


import math


class Pizza:
    def __init__(self, radius, ingredients):
        self.radius = radius
        self.ingredients = ingredients

    def __repr__(self):
        return f"Pizza({self.radius!r}, " f"{self.ingredients!r})"

    @classmethod
    def margherita(cls):
        return cls(3, ["mozzarella", "tomatoes"])

    @classmethod
    def prosciutto(cls):
        return cls(4, ["mozzarella", "tomatoes", "ham"])

    def area(self):
        return self.circle_area(self.radius)

    @staticmethod
    def circle_area(r):
        return r ** 2 * math.pi


Pizza(4, ["cheese", "tomatoes"])
Pizza(2, ["mozzarella", "tomatoes"])
Pizza(3, ["mozzarella", "tomatoes", "ham", "mushrooms"])
Pizza(4, ["mozzarella"] * 4)


print(Pizza.margherita())

print(Pizza.prosciutto())


p = Pizza(4, ["mozzarella", "tomatoes"])
print(p)

print(p.area())

print(Pizza.circle_area(4))