data classes in python
Published: 2023-06-09 17:00:51

Python is an object-oriented programming language that provides various ways to define and use classes.

##python classes

A python class is a blueprint for creating instances / objects.  A normal class is a user-defined class that doesn't include any special attributes or methods.  Normal classes use a constructor method, ` __init__ ` that initializes the class instance with default or provided inputs. 


here's an example:

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

##data classes

a data class is a special class created using the @dataclass decorator. they are meant to be used for simple, immutable data structures, sans behavior. 

here's an example of.a nifty little data class in Python: 

```
from dataclasses import dataclass

@dataclass
class Person:
    name: str
    age: int

```

#normal & data classes: differences

##brevity:

Data classes are more concise than normal classes, as they require much less code to define.  The parameters are automatically generated, and a `__repr__` is provided for us.

```
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __repr__(self):
        return f"Point(x={self.x}, y={self.y})"

@dataclass
class Point2:
    x: int
    y: int

```

Writing attributes is a lot quicker too in a data class. Let's have a look below.

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

    def get_name(self):
        return self.name

    def set_name(self, name):
        self.name = name

    def get_age(self):
        return self.age

    def set_age(self, age):
        self.age = age
```

Here, we created a normal class named Person and defined two attributes, name and age using a couple pairs of setter and getter functions. 


Now, let's create a data class with two attributes. 

```
from dataclasses import dataclass

@dataclass
class Person:
    name: str
    age: int
```

Super brief, super legible, super cool!

#mutability:

Data classes are immutable by default, while normal classes are mutable. 
Which means after instances of data classes are made, their attributes can't be edited.

Is it good to have an object that can't be edited? Like most things in life, it depends. 

## type-hinting:

Type hinting is another area where data classes and normal classes differ. With data classes, we can specify the types of our attributes in the class definition. This is done using Python's built-in type annotations. Here's an example:

```
from typing import List

@dataclass
class Person:
    name: str
    age: int
    hobbies: List[str]
```
As you can see, we specified the types of the name, age, and hobbies attributes. This allows Python's type checker to catch any type errors during development, which can help prevent bugs and improve the reliability of our code.

In contrast, with normal classes, we have to manually specify the types of our attributes in the constructor or in the class definition. Here's an example:
```
from typing import List

class Person:
    def __init__(self, name: str, age: int, hobbies: List[str]):
        self.name = name
        self.age = age
        self.hobbies = hobbies
```

#equality: 

By default, data classes define equality based on the values of their attributes, meaning that two instances of a data class are considered equal if all their attributes have the same values.

```
from dataclasses import dataclass

@dataclass
class Person:
    name: str
    age: int

p1 = Person("Alice", 30)
p2 = Person("Alice", 30)
print(p1 == p2)  # True
```

In contrast, normal classes define equality based on object identity, meaning that two instances of a normal class are considered equal only if they are the same object in memory.

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

p1 = Person("Alice", 30)
p2 = Person("Alice", 30)
print(p1 == p2)  # False
```

Wow!

#conclusion 

we use both data and normal classes in python to represnt objects. While data classes are more concise and legible, normal classes give us much more versatility.  

#TLDR: @dataclass(es) are great for simple data structures and "Normal" classes are good when you need more flexibility and function inside your class. thank you please #like #subscribe #comment #follow #your #heart