# Criar objetos e classes Python

As classes Python são como **modelos ou planos de construção**. Com elas, pode escrever código reutilizável na forma de atributos e métodos.

## O que são as aulas de Python?

Uma classe é um **conceito abstrato** que define atributos e métodos que um objeto pode ter. As classes Python funcionam como modelos para criar objetos concretos, que são instâncias dessa classe. Por exemplo, uma classe poderia ser chamada `Coche` e poderia ter atributos como cor e marca, e métodos como `__conducir__` ou `__frenar__`.

Cada objeto de uma classe pode ter seus próprios valores para os atributos, mas **compartilha os métodos e a estrutura básica de comportamento com outras instâncias** da mesma classe. Por exemplo, é possível criar um objeto `mi_coche` da classe `Coche` com a cor `__rojo__` e a marca `__Toyota__`, e a instância herdará automaticamente os métodos `__conducir__` ou `__frenar__` da classe.

## Como criar classes em Python

Você pode definir classes em Python escrevendo a palavra-chave `class` seguida do nome da classe e dois pontos.

```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}"
```

Neste código Python, foi criada uma classe chamada `MyClass` que tem um **construtor** `__init__` que é acedido ao criar um objeto e que inicializa dois atributos, o `attribute1` e o `attribute2`. O método `my_method` retorna uma cadeia formatada que contém os valores desses atributos.

Para criar um objeto baseado nesta classe, deve utilizar o nome da classe seguido de parênteses:

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

## Exemplos de utilização das classes Python

As classes Python podem criar sistemas complexos e relações entre diferentes entidades. A seguir, mostramos algumas formas de trabalhar com elas.

### A função `__str()__`

A função `__str__()` em Python é um método especial que pode ser definido dentro das classes Python. Quando implementada, ela retorna uma string com uma **representação simples de um objeto**. Pode-se aplicar a função `str()` diretamente ao objeto ou combiná-la com uma instrução `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
```

Neste código, o método `__str__()` dentro da classe `Person` cria uma **cadeia formatada** que contém o nome e a idade de uma pessoa. Quando é executado `print(person1)`, chama automaticamente o método `__str__()` do objeto `person1` e resulta na cadeia que este método devolveu.

### Definir métodos em classes Python

Em Python, também é possível definir métodos dentro de uma classe para executar operações sobre os objetos dessa classe. Assim, os objetos criados podem chamar esses 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
```

No exemplo anterior, foi criada a classe `Rectangle`, que inclui os dois métodos `area()` e `perimeter()`. Esses métodos servem para calcular a área e o perímetro de um retângulo com base nos valores de comprimento e largura que foram passados ao inicializar o objeto. Em Python, `self` em um método de classe representa uma **referência ao objeto atual** ao qual o método é aplicado.

O objeto `my_rectangle` é criado com um comprimento de 5 e uma largura de 10. Em seguida, os métodos `area()` e `perimeter()` foram chamados sobre este objeto para calcular os valores respetivos.

### Alterar as propriedades dos objetos

Pode utilizar o operador ponto `.` para aceder a **atributos específicos de um objeto** e atualizar os seus valores. Pode atribuir novos valores diretamente ao atributo, conforme pode ver a seguir:

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

A palavra-chave `del` serve para eliminar propriedades de um objeto. No exemplo a seguir, a propriedade name do objeto person1 está a ser eliminada:

```python
del person1.name
```

Nota Tenha em atenção que as variáveis de instância são diferentes das variáveis de classe Python ([Python class variables](https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/variaveis-de-classe-python/)). As variáveis de classe **são definidas fora do construtor** e só podem ser modificadas através do nome da classe.


This is a markdown version of: [https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/aulas-de-python/](https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/aulas-de-python/) for AI/LLM consumption.