# Crear objetos y clases de Python

Las clases de Python son como **plantillas o planos de construcción**. Con ellas puedes escribir código reutilizable en forma de atributos y métodos.

## ¿Qué son las clases de Python?

Una clase es un **concepto abstracto** que define atributos y métodos que un objeto puede tener. Las clases de Python actúan como plantillas para crear objetos concretos, que son instancias de esa clase. Por ejemplo, una clase podría llamarse `Coche` y podría tener atributos como color y marca, y métodos como `__conducir__` o `__frenar__`.

Cada objeto de una clase puede tener sus propios valores para los atributos, pero **comparte los métodos y la estructura básica de comportamiento con otras instancias** de la misma clase. Por ejemplo, se puede crear un objeto `mi_coche` de la clase `Coche` con el color `__rojo__` y la marca `__Toyota__` y la instancia heredará automáticamente los métodos `__conducir__` o `__frenar__` de la clase.

## Cómo crear clases de Python

Puedes definir clases en Python escribiendo la palabra clave `class` seguida del nombre de la clase y dos puntos.

```python
class MyClass:
    # Constructor method called when creating an object
    def __init__(self, attribute1, attribute2):
        self.attribute1 = attribute1
        self.attribute2 = attribute2
    
    # Method defined within the class
    def my_method(self):
        return f"Attribute 1: {self.attribute1}, Attribute 2: {self.attribute2}"
```

En este código Python, se ha creado una clase llamada `MyClass` que tiene un **constructor** `__init__` al que se accede al crear un objeto y que inicializa dos atributos, el `attribute1` y el `attribute2`. El método `my_method` devuelve una cadena formateada que contiene los valores de esos atributos.

Para crear un objeto basado en esta clase, debes utilizar el nombre de la clase seguido de paréntesis:

```python
object1 = MyClass("Value 1", "Value 2")
# Calling a method of the object
result = object1.my_method()
```

## Ejemplos de uso de las clases de Python

Las clases de Python pueden crear sistemas complejos y relaciones entre distintas entidades. A continuación, te enseñamos algunas formas de trabajar con ellas.

### La función `__str()__`

La función `__str__()` en Python es un método especial que puedes definir dentro de las clases de Python. Cuando se implementa, devuelve una cadena con una **representación sencilla de un objeto**. Puedes aplicar la función `str()` directamente al objeto o combinarla con una instrucción `print()`.

```python
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def __str__(self):
        return f"Name: {self.name}, Age: {self.age}"
person1 = Person("Alice", 30)
print(person1) # Output: Name: Alice, Age: 30
```

En este código, el método `__str__()` dentro de la clase `Person` crea una **cadena formateada** que contiene el nombre y la edad de una persona. Cuando se ejecuta `print(person1)`, llama automáticamente al método `__str__()` del objeto `person1` y da como resultado la cadena que este método ha devuelto.

### Definir métodos en clases de Python

En Python también es posible establecer métodos dentro de una clase para ejecutar operaciones sobre los objetos de esta clase. Por lo tanto, los objetos creados pueden llamar a dichos métodos.

```python
class Rectangle:
    def __init__(self, length, width):
        self.length = length
        self.width = width
    
    def area(self):
        return self.length * self.width
    def perimeter(self):
        return 2 * (self.length + self.width)
# Creating an object of the class
my_rectangle = Rectangle(5, 10)
# Calling methods of the object
area = my_rectangle.area()
perimeter = my_rectangle.perimeter()
# Printing the calculated values
print("Area =", area) # Output: Area = 50
print("Perimeter =", perimeter) # Output: Perimeter = 30
```

En el ejemplo anterior, se ha creado la clase `Rectangle`, que incluye los dos métodos `area()` y `perimeter()`. Estos métodos sirven para calcular el área y el perímetro de un rectángulo basándose en los valores de longitud y anchura que se pasaron al inicializar el objeto. En Python, `self` en un método de clase representa una **referencia al objeto actual** al que se aplica el método.

El objeto `my_rectangle` se crea con una longitud de 5 y una anchura de 10. Después, se ha llamado a los métodos `area()` y `perimeter()` sobre este objeto para calcular los valores respectivos.

### Cambiar las propiedades de objetos

Puedes utilizar el operador punto `.` para acceder a **atributos específicos de un objeto** y actualizar sus valores. Puedes asignar nuevos valores directamente al atributo tal y como puedes ver a continuación:

```python
person1.name = "Sarah"
person1.age = 35
```

La palabra clave `del` sirve para eliminar propiedades de un objeto. En el ejemplo que sigue, se está eliminando la propiedad name del objeto person1:

```python
del person1.name
```

Nota Ten en cuenta que las variables de instancia son diferentes de las variables de clase de Python ([Python class variables](https://www.ionos.es/digitalguide/paginas-web/desarrollo-web/python-class-variables/)). Las variables de clase **se definen fuera del constructor** y solo pueden modificarse a través del nombre de la clase.


This is a markdown version of: [https://www.ionos.es/digitalguide/paginas-web/desarrollo-web/python-classes/](https://www.ionos.es/digitalguide/paginas-web/desarrollo-web/python-classes/) for AI/LLM consumption.