<div class="text-justify">

<center><h1>class newPost():</h1></center>

<center>
![Python-Classes_Watermarked.webp](https://files.peakd.com/file/peakd-hive/jesalmofficial/23yJLhNQ2gcbMFLEvueUEsQQVgix4cw2gdb6Gnoe6BF7BLait7UvnK6zM6Z5TpT9XekLr.webp)
<br>[Shoutout to Real Python](https://realpython.com/python-classes/)</center>

![HiveDivider.png](https://files.peakd.com/file/peakd-hive/jesalmofficial/EoGvX4Va6X4ZfjnYkvBhFi2bqZsCrwoqpWhwgmGDPKVDS9eeZ4zF8foqAfcm44mn84d.png)

<center><h3>In this article you'll find:</h3></center>
* <b>Introduction</b>
* <b>What is a class?/What is an object?</b>
* <b>What do classes and objects look like in code?</b>
* <b>__init__ Function()</b>
* <b>How to create a method inside a class</b>
* <b>Operations with objects</b>

![HiveDivider.png](https://files.peakd.com/file/peakd-hive/jesalmofficial/EoGvX4Va6X4ZfjnYkvBhFi2bqZsCrwoqpWhwgmGDPKVDS9eeZ4zF8foqAfcm44mn84d.png)

We are heading to the end of the basics: We went through If conditionals, switch-case, for and while cycles, functions, lists, tuples, dictionaries, sets, operations with arrays and many other elements that have brought us to the point of knowledge of basic concepts.

However, today it is time to go into new territory: Classes. When working with object-oriented programming languages, we will come across this word a lot. But what is it?

It is precisely what we will see in this post, which, after reading it, will make you understand how these programming components work perfectly, being ready to apply them in your programs. That said:

<center>Let's begin!</center>

![HiveDivider.png](https://files.peakd.com/file/peakd-hive/jesalmofficial/EoGvX4Va6X4ZfjnYkvBhFi2bqZsCrwoqpWhwgmGDPKVDS9eeZ4zF8foqAfcm44mn84d.png)

<center><h2>What is a class? / What is an object?</h2></center>

<center>
![Python-Classes-Instances.png](https://files.peakd.com/file/peakd-hive/jesalmofficial/Ep7scR6P77Bma1nnnd7EY9Unyqs5sgPYrUyjqrtRHqQMTyPtAtFwazzktHohG4iCdG9.png)
<br>[Shoutout to STechies](https://www.stechies.com/classes-instances-python/)</center>

First, let's take a look at what an object is:

An object is an entity that has properties and methods that we can apply to it. This means that a lot of elements in Python are objects, such as:

* Variables
* Functions
* Modules

Since they fulfill the conditions of methods and properties. Now that we know this, let's define what a class is:

Classes are DataTypes that are created to represent complex objects. That is to say, a class is the blueprint to create an object. If we remember a very common DataType such as string, we can see that this is a class itself. If we create a variable (object) of type string called test:

```
test = 'testing string'
```

And we apply a method of the string class itself as Capitalize.

```
test.capitalize()
print(test)

>>> TESTING STRING
```

We can see that the test object calls the string class to look for the capitalize method and apply it. This is what happens with all classes. If we are still skeptical as to whether our string is a class, just write the following:

```
print(type(test))

>>> <class 'string'>
```

Now, how would we define the properties and methods of a class? For this, we take the following example:

![image.png](https://files.peakd.com/file/peakd-hive/jesalmofficial/23tHbr9ykvofyRpXLMZX9Ny5NuHHWZDUqLAVC8mwa1K3jXSLnN53FodeywEKJK7LKAa98.png)

Car will be our class, having both properties and methods. The properties will be the attributes of the car, such as the color, the license plate number, the amount of fuel in the gas, among many others.

On the other hand the methods, which are functions associated to an object ([More about this in this article](https://hive.blog/hive-196387/@jesalmofficial/the-difference-between-a-method-and-a-function-coding-basics)) will be running the car, changing directions, braking, etc...

This is the working principle behind each class. So, if we decided to create or use a new car, it would have the properties and methods of the class.

We already know what is behind a class. However, we still don't know how to write it in code. Let's take a look at this.


![HiveDivider.png](https://files.peakd.com/file/peakd-hive/jesalmofficial/EoGvX4Va6X4ZfjnYkvBhFi2bqZsCrwoqpWhwgmGDPKVDS9eeZ4zF8foqAfcm44mn84d.png)

<center><h2>What do classes and objects look like in code?</h2></center>

<center>
![JT_1and2.png](https://files.peakd.com/file/peakd-hive/jesalmofficial/23tw6Az9NEkKR3VeP5gxLCvwjsdgGJJfgonfFugd7addDqUrP1q2Z4MyHwQaXkcLM6HkH.png)
<br>[Shoutout to Texas Instruments](https://education.ti.com/en/bulletinboard/2022/python-coding-classes)</center>

To create a class, the syntax will depend on your programming language. In the case of python, we only have to use the keyword Class:

```
class myClass:
```

And if we want to add a property to it, we can create a variable inside it.

```
class myClass:
      number = 5
```

We know that if we try to access number outside the class, this will be out of bounds and we will get an error like the following one:

```
NameError: name 'x' is not defined
```

If we would like to access number, we have to create an object first. For this, we create a variable that invokes the class and write:

```
new_object = myClass()
```

And thus, we would have our first object. Now, if we want to call number, we use

```
print(new_object.x)

>>> 5
```
However, this is the simplest form of a class, which is not often used in practical examples. To understand these, you will need to know the __init__() function.

![HiveDivider.png](https://files.peakd.com/file/peakd-hive/jesalmofficial/EoGvX4Va6X4ZfjnYkvBhFi2bqZsCrwoqpWhwgmGDPKVDS9eeZ4zF8foqAfcm44mn84d.png)

<center><h2>__init__() Function</h2></center>

<center>
![8stPc.jpg](https://files.peakd.com/file/peakd-hive/jesalmofficial/23t77B8EyuzvYZxdDys1fg7tVNg8BRMgE1pnsd4vUweemDp2t6xPuuZDCWxeLETAe4n8G.jpg)
<br>[Shoutout to Harsh Tiwari in Stack Overflow](https://stackoverflow.com/questions/71527949/what-is-meaning-of-superclassname-self-init-in-python)</center>

Whenever a class is created, a built_in function (i.e., a Python function) called __init__() or constructor is executed, which will allow us to save custom parameters when creating an object. If we look at the following example:

```
class Person:
  def __init__(self, name, age):
    self.name = name
    self.age = age
```

We will usually see several parameters. The self, which will simply reference the current instance of the class, and the parameters to which the user will enter information when creating the object. Seeing this in practice
 ```
person1 = Person("Jenny", 24)
 ``` 

We see how we assign the name and age parameters directly when creating the class. Now, if we print both parameters.

```
print(person1.name)
>>> Jenny
print(person1.age)
>>> 24
```

If we would like to create another object and add a custom name and age to it, we can do it without problems.

These parameters are known as attributes or properties. However, we are still missing the other part of the equation: what happens if we want to define a method inside our class?

![HiveDivider.png](https://files.peakd.com/file/peakd-hive/jesalmofficial/EoGvX4Va6X4ZfjnYkvBhFi2bqZsCrwoqpWhwgmGDPKVDS9eeZ4zF8foqAfcm44mn84d.png)

<center><h2>How to create a method inside a class</h2></center>

<center>
![class_method.webp](https://files.peakd.com/file/peakd-hive/jesalmofficial/Eo4Jmy95wEQuDFG8amdGTmhoEzRzZRGrpTbsuW26SPVBZF8S5LeXx4a35g2o9YCyKmN.webp)
<br>[Shoutout to PYnative](https://pynative.com/python-class-method/)</center>

Since the methods are functions of the class itself, which the object will then call, the syntax will be the same. The only difference is that now we only use self as parameter, since it will represent the current instance of the class (the object).

```
class Person:
  def __init__(self, name, age):
    self.name = name
    self.age = age

def method_for_class(self):
     print("Welcome" + self.name).
```

Now, if we create our object and call this method:

```
person1 = Person('Mary',28)
person1.method_for_class()

>>> Welcome Mary
```

![HiveDivider.png](https://files.peakd.com/file/peakd-hive/jesalmofficial/EoGvX4Va6X4ZfjnYkvBhFi2bqZsCrwoqpWhwgmGDPKVDS9eeZ4zF8foqAfcm44mn84d.png)

<center><h2>Operations with objects</h2></center>

<center>
![descarga.jpg](https://files.peakd.com/file/peakd-hive/jesalmofficial/23tw8LdwmEVRczSiKayQB34ZgfGMFmBsTeLCAbATBg8raHJxxGeh67PTLqLJyJJoErSMs.jpg)
<br>[Shoutout to Simplilearn.com](https://www.simplilearn.com/tutorials/python-tutorial/objects-and-classes-in-python)</center>

Let's say you want to change an attribute on your object, how would we do this?

Just as with any variable, we modify the value of some property in an object by accessing the particular object and assigning a new value. This, in the following way:

```
object.attribute = new_value
```

Referring to the previous example. If we want to change the age of mary to 29 years, we would only have to write:

```
person1.age = 29

print(person1.age)
>>> 29
```

If we want to change name, we would just type person1.name = and then the new value. Now, this works when we want to modify a value, but there are certain cases where we want to delete a property for an object.

To do this, we just use the keyword del:

```
of the person1.age

print(person1.age)
>>> AttributeError: 'Person' object has no attribute 'age'.
```

And if we want to delete the object completely, we write:

```
of the person1

>>>NameError: 'p1' is not defined
```

![HiveDivider.png](https://files.peakd.com/file/peakd-hive/jesalmofficial/EoGvX4Va6X4ZfjnYkvBhFi2bqZsCrwoqpWhwgmGDPKVDS9eeZ4zF8foqAfcm44mn84d.png)

The concept of class is the first encounter with object-oriented programming, where we obtain the knowledge to create a blueprint for new objects, assigning them the attributes and methods we want.

After reading this, you will be able to create your own classes and implement them in your programs. This will save you countless lines of code and you will be able to structure your code in a much simpler way. Enjoy it.

![HiveDivider.png](https://files.peakd.com/file/peakd-hive/jesalmofficial/EoGvX4Va6X4ZfjnYkvBhFi2bqZsCrwoqpWhwgmGDPKVDS9eeZ4zF8foqAfcm44mn84d.png)

<center>Thank you for your support and good luck!</center>

![HiveDivider.png](https://files.peakd.com/file/peakd-hive/jesalmofficial/EoGvX4Va6X4ZfjnYkvBhFi2bqZsCrwoqpWhwgmGDPKVDS9eeZ4zF8foqAfcm44mn84d.png)

![@jesalmofficial.png](https://files.peakd.com/file/peakd-hive/jesalmofficial/23uFM31KVmT4iWbMCQWto9Nnz5WENKeMFhkXX2X37NpFPEcUSW7vSx9AEF1rSAVaaAcXP.png)

![HiveDivider.png](https://files.peakd.com/file/peakd-hive/jesalmofficial/EoGvX4Va6X4ZfjnYkvBhFi2bqZsCrwoqpWhwgmGDPKVDS9eeZ4zF8foqAfcm44mn84d.png)

<center><h1>class newPost():</h1></center>

<center>
![Python-Classes_Watermarked.webp](https://files.peakd.com/file/peakd-hive/jesalmofficial/23yJLhNQ2gcbMFLEvueUEsQQVgix4cw2gdb6Gnoe6BF7BLait7UvnK6zM6Z5TpT9XekLr.webp)
<br>[Shoutout to Real Python](https://realpython.com/python-classes/)</center>

![HiveDivider.png](https://files.peakd.com/file/peakd-hive/jesalmofficial/EoGvX4Va6X4ZfjnYkvBhFi2bqZsCrwoqpWhwgmGDPKVDS9eeZ4zF8foqAfcm44mn84d.png)

<center><h3>En este artículo encontrarás:</h3></center>
* <b>Introducción</b>
* <b>¿Qué es una clase?/¿Qué es un objeto?</b>
* <b>¿Cómo luce una clase y un objeto en código?</b>
* <b>Función __init__()</b>
* <b>Como crear un método dentro de una clase</b>
* <b>Operaciones con objetos</b>

![HiveDivider.png](https://files.peakd.com/file/peakd-hive/jesalmofficial/EoGvX4Va6X4ZfjnYkvBhFi2bqZsCrwoqpWhwgmGDPKVDS9eeZ4zF8foqAfcm44mn84d.png)

Nos dirigimos a final de lo básico: Pasamos por condicionales If, switch-case, ciclos for y while, funciones, listas, tuplas, diccionarios, sets, operaciones con arreglos y muchos otros elementos que nos han llevado al punto del conocimiento de conceptos básicos.

Sin embargo, el día de hoy es tiempo de adentrarnos en nuevo territorio: El de las clases. Al trabajar con lenguajes de programación orientada a objetos, nos encontraremos con esta palabra un montón. Pero, ¿Qué es esto?

Es precisamente lo que veremos en este post, el cual, después de leerlo, te hará comprender como funcionan estos componentes de programación a la perfección, estando listo para aplicarlos en tus programas. Dicho esto:

<center>¡Comencemos!</center>

![HiveDivider.png](https://files.peakd.com/file/peakd-hive/jesalmofficial/EoGvX4Va6X4ZfjnYkvBhFi2bqZsCrwoqpWhwgmGDPKVDS9eeZ4zF8foqAfcm44mn84d.png)

<center><h2>¿Qué es una clase?/¿Qué es un objeto?</h2></center>

<center>
![Python-Classes-Instances.png](https://files.peakd.com/file/peakd-hive/jesalmofficial/Ep7scR6P77Bma1nnnd7EY9Unyqs5sgPYrUyjqrtRHqQMTyPtAtFwazzktHohG4iCdG9.png)
<br>[Shoutout to STechies](https://www.stechies.com/classes-instances-python/)</center>

Primero, echemos un vistazo a lo que es un objeto:

Un objeto es una entidad que tiene propiedades y métodos que podemos aplicar a esta. Esto quiere decir que una gran cantidad de elementos en Python son objetos, como lo son:

* Variables
* Funciones
* Módulos

Ya que cumplen con las condiciones de métodos y propiedades. Ahora que sabemos esto, pasamos a definir que es una clase:

Las clases son DataTypes que se crean para representar objetos complejos. Es decir, una clase es el plano para crear un objeto. Si recordamos un DataType muy común como lo es el string, podemos ver que este es una clase en si. Si creamos una variable (objeto) de tipo string llamada test:

```
test = 'testing string'
```

Y le aplicamos un método propio de la clase string como lo es Capitalize.

```
test.capitalize()
print(test)

>>> TESTING STRING
```

Podemos ver que el objeto test llama a la clase string para buscar el método capitalize y aplicarlo. Esto es lo que pasa con todas las clases. Si aún estamos escépticos con respecto a si nuestra string es una clase, solo escribe lo siguiente:

```
print(type(test))

>>> <class 'string'>
```

Ahora ¿Como definiríamos las propiedades y métodos de una clase? Para esto, tomamos el siguiente ejemplo:


![image.png](https://files.peakd.com/file/peakd-hive/jesalmofficial/23tHbr9ykvofyRpXLMZX9Ny5NuHHWZDUqLAVC8mwa1K3jXSLnN53FodeywEKJK7LKAa98.png)


Car será nuestra clase, teniendo tanto propiedades como métodos. Las propiedades serán los atributos del auto, como lo son el color, el número de placa, la cantidad de combustible en el gas, entre muchos otros.

Por otro lado los métodos, que son funciones asociadas a un objeto ([Más sobre esto en este artículo](https://hive.blog/hive-196387/@jesalmofficial/the-difference-between-a-method-and-a-function-coding-basics)) serán el acelerar, cambiar direcciones, frenar, etc...

Este es el principio de funcionamiento detrás de cada clase. Entonces, si decidieramos crear o usar un nuevo auto, este tendría las propiedades y los métodos de la clase.

Ya sabemos que hay detrás de una clase. Sin embargo, todavía no sabemos como escribirla en código. Veamos esto.

![HiveDivider.png](https://files.peakd.com/file/peakd-hive/jesalmofficial/EoGvX4Va6X4ZfjnYkvBhFi2bqZsCrwoqpWhwgmGDPKVDS9eeZ4zF8foqAfcm44mn84d.png)

<center><h2>¿Cómo luce una clase y un objeto en código?</h2></center>

<center>
![JT_1and2.png](https://files.peakd.com/file/peakd-hive/jesalmofficial/23tw6Az9NEkKR3VeP5gxLCvwjsdgGJJfgonfFugd7addDqUrP1q2Z4MyHwQaXkcLM6HkH.png)
<br>[Shoutout to Texas Instruments](https://education.ti.com/en/bulletinboard/2022/python-coding-classes)</center>

Para crear una clase, la sintaxis dependerá de tu lenguaje de programación. En el caso de python, solo tenemos que usar la keyword Class:

```
class myClass:
```

Y si queremos añadirle una propiedad, podemos crear una variable dentro de esta.

```
class myClass:
      number = 5
```

Sabemos que si tratamos de acceder a number fuera de la clase, esto se encontrará fuera de los límites y nos saltará un error como el siguiente:

```
NameError: name 'x' is not defined
```

Si quisieramos acceder a number, tenemos que crear un objeto primero. Para esto, creamos una variable que invoque la clase y escribimos:

```
new_object = myClass()
```

Y así, tendríamos nuestro primer objeto. Ahora, si queremos llamar a number, usamos:

```
print(new_object.x)

>>> 5
```

Sin embargo, esta es la forma más sencilla de una clase, lo cual no suele usarse en ejemplos prácticos. Para entender estos, hará falta conocer la función __init__()

![HiveDivider.png](https://files.peakd.com/file/peakd-hive/jesalmofficial/EoGvX4Va6X4ZfjnYkvBhFi2bqZsCrwoqpWhwgmGDPKVDS9eeZ4zF8foqAfcm44mn84d.png)

<center><h2>Función __Init__()</h2></center>

<center>
![8stPc.jpg](https://files.peakd.com/file/peakd-hive/jesalmofficial/23t77B8EyuzvYZxdDys1fg7tVNg8BRMgE1pnsd4vUweemDp2t6xPuuZDCWxeLETAe4n8G.jpg)
<br>[Shoutout to Harsh Tiwari in Stack Overflow](https://stackoverflow.com/questions/71527949/what-is-meaning-of-superclassname-self-init-in-python)</center>

Siempre que se crea una clase, se ejecuta una función built_in (Es decir, una función propia de Python) llamada __init__() o constructor. Lo que hará esta es que nos permitirá grabar parámetros personalizados al crear un objeto. Si observamos el siguiente ejemplo:

```
class Person:
  def __init__(self, name, age):
    self.name = name
    self.age = age
```

Veremos generalmente varios parámetros. El self, que simplemente hará referencia a la instancia actual de la clase, y los parámetros a los cuales el usuario introducirá la información cuando cree el objeto. Viendo esto en práctica:

```
person1 = Person("Jenny", 24)
``` 

Vemos como asignamos los parámetros de name y age directamente al crear la clase. Ahora, si imprimimos ambos parámetros.

```
print(person1.name)
>>> Jenny
print(person1.age)
>>> 24
```

Si quisieramos crear otro objeto y agregarle un nombre y edad personalizado, ya podemos hacerlo sin problemas.

A estos parámetros es a los que conoceremos como atributos o propiedades. Sin embargo, aún nos falta la otra parte de la ecuación. ¿Qué pasa si queremos definir un método dentro de nuestra clase?

![HiveDivider.png](https://files.peakd.com/file/peakd-hive/jesalmofficial/EoGvX4Va6X4ZfjnYkvBhFi2bqZsCrwoqpWhwgmGDPKVDS9eeZ4zF8foqAfcm44mn84d.png)

<center><h2>Como crear un método dentro de una clase</h2></center>

<center>
![class_method.webp](https://files.peakd.com/file/peakd-hive/jesalmofficial/Eo4Jmy95wEQuDFG8amdGTmhoEzRzZRGrpTbsuW26SPVBZF8S5LeXx4a35g2o9YCyKmN.webp)
<br>[Shoutout to PYnative](https://pynative.com/python-class-method/)</center>

Ya que los métodos son funciones propias de la clase, que luego el objeto llamará, la sintaxis será la misma. La única diferencia es que ahora solo usamos como parámetro a self, ya que este representará la instancia actual de la clase (El objeto).

```
class Person:
  def __init__(self, name, age):
    self.name = name
    self.age = age

def method_for_class(self):
     print("Welcome" + self.name)
```

Ahora, si creamos nuestro objeto y llamamos a este método:

```
person1 = Person('Mary',28)
person1.method_for_class()

>>> Welcome Mary
```

![HiveDivider.png](https://files.peakd.com/file/peakd-hive/jesalmofficial/EoGvX4Va6X4ZfjnYkvBhFi2bqZsCrwoqpWhwgmGDPKVDS9eeZ4zF8foqAfcm44mn84d.png)

<center><h2>Operaciones con objetos</h2></center>

<center>
![descarga.jpg](https://files.peakd.com/file/peakd-hive/jesalmofficial/23tw8LdwmEVRczSiKayQB34ZgfGMFmBsTeLCAbATBg8raHJxxGeh67PTLqLJyJJoErSMs.jpg)
<br>[Shoutout to Simplilearn.com](https://www.simplilearn.com/tutorials/python-tutorial/objects-and-classes-in-python)</center>

Digamos que quieres cambiar un atributo en tu objeto, ¿Como haríamos esto?

De igual forma que con cualquier variable, modificamos el valor de alguna propiedad en un objeto al acceder al objeto en particular y asignar un nuevo valor. Esto, de la siguiente forma:

```
object.attribute = new_value
```

Referenciando al ejemplo anterior. Si queremos cambiar la edad de mary a 29 años, solo tendríamos que escribir:

```
person1.age = 29

print(person1.age)
>>> 29
```

Si queremos cambiar name, solo tendríamos que colocar person1.name = y entonces el nuevo valor. Ahora bien, esto funciona cuando queremos modificar un valor, pero existen ciertos casos donde queremos borrar una propiedad para un objeto.

Para hacer esto, solo usamos la keyword del:

```
del person1.age

print(person1.age)
>>> AttributeError: 'Person' object has no attribute 'age'
```

Y si queremos borrar el objeto por completo, escribimos:

```
del person1

>>>NameError: 'p1' is not defined
```

![HiveDivider.png](https://files.peakd.com/file/peakd-hive/jesalmofficial/EoGvX4Va6X4ZfjnYkvBhFi2bqZsCrwoqpWhwgmGDPKVDS9eeZ4zF8foqAfcm44mn84d.png)

El concepto de clase es el primer encuentro con la programación orientada a objetos, donde obtenemos el conocimiento para crear un plano a nuevos objetos, asignándoles los atributos y métodos que queramos.

Después de leer esto, estarás en condiciones para crear tu propias clases e implementarlas en tus programas. Esto te ahorrará incontables líneas de código y podrás estructurar tu código de una forma mucho más sencilla. Disfrutalo.

![HiveDivider.png](https://files.peakd.com/file/peakd-hive/jesalmofficial/EoGvX4Va6X4ZfjnYkvBhFi2bqZsCrwoqpWhwgmGDPKVDS9eeZ4zF8foqAfcm44mn84d.png)

<center>¡Gracias por tu apoyo y buena suerte!</center>

![HiveDivider.png](https://files.peakd.com/file/peakd-hive/jesalmofficial/EoGvX4Va6X4ZfjnYkvBhFi2bqZsCrwoqpWhwgmGDPKVDS9eeZ4zF8foqAfcm44mn84d.png)


![@jesalmofficial.png](https://files.peakd.com/file/peakd-hive/jesalmofficial/23uFM31KVmT4iWbMCQWto9Nnz5WENKeMFhkXX2X37NpFPEcUSW7vSx9AEF1rSAVaaAcXP.png)


</div>