Class

To use a class, create an object or instance of that class. This is done by calling the class name followed by parentheses.

obj = MyClass(arg1_value, arg2_value)

Class variables can be accessed directly using the class name, while instance variables are accessed through the object.

MyClass.class_var       # access class variable
obj.instance_var1       # access instance variable

Instance methods are called on the object and can access the instance variables and class variables.

obj.instance_method()   # call instance method

Class inheritance is a mechanism that allows a class to inherit properties and methods from another class. The class that is being inherited from is called the parent or superclass, and the class inheriting from it is called the child or subclass.

To inherit from a class, the child class is defined using the following syntax:

class ChildClass(ParentClass):
    # child class definition

The child class now has access to all the properties and methods of the parent class, and can also define its own additional properties and methods. This allows for code reuse and the ability to create specialized classes that inherit and extend functionality from a more general class.

class Animal:
    def __init__(self, name):
        self.name = name

    def sound(self):
        pass

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)
        self.breed = breed

    def sound(self):
        return "Woof!"

class Cat(Animal):
    def __init__(self, name, color):
        super().__init__(name)
        self.color = color

    def sound(self):
        return "Meow!"

Creating instances of the child classes

dog = Dog("Buddy", "Labrador")
cat = Cat("Simba", "Orange")

print(dog.name)  # Output: Buddy
print(dog.breed)  # Output: Labrador
print(dog.sound())  # Output: Woof!

print(cat.name)  # Output: Simba
print(cat.color)  # Output: Orange
print(cat.sound())  # Output: Meow!

In this example, the Dog and Cat classes inherit from the Animal class. They both override the sound() method defined in the parent class, providing their own implementation. The child classes also define additional properties specific to their type of animal.

A data class is a type of class leveraging the `dataclasses` module. It provides a convenient way to define classes that are primarily used to hold data, similar to structs in other programming languages.

Use a dataclass by:

1. Import the dataclasses.
2. Decorate the class with @dataclass
   • Add the \`@dataclass\` decorator just above the class declaration. This decorator will automatically generate common methods such as \`\_<sub>init</sub>\_<sub>()</sub>\`, \`\_<sub>repr</sub>\_<sub>()</sub>\`, \`\_<sub>eq</sub>\_<sub>()</sub>\`, etc., based on the class attributes.
3. Define class attributes:
   • Inside the class, define the attributes that represent the data you want to store. Each attribute is defined by assigning a value like you would in a regular class.

4. Customize the behavior (optional):

   • You can customize the behavior of the generated methods by specifying various class decorators, such as \`@property\`, \`@staticmethod\`, and \`@classmethod\`.

   from dataclasses import dataclass

   @dataclass class Person: name: str age: int country: str = "Unknown" # You can also provide default values

   def greet(self): print(f"Hello, I'm {self.name} from {self.country}!")

In the above example, the \`Person\` class is defined as a data class using the \`@dataclass\` decorator. It has three attributes: \`name\`, \`age\`, and \`country\`. The \`country\` attribute is assigned a default value of "Unknown". It also has a method called \`greet()\` that prints a greeting.

The main difference between a data class and a normal class is that a data class automatically generates methods such as \`\_<sub>init</sub>\_<sub>()</sub>\`, \`\_<sub>repr</sub>\_<sub>()</sub>\`, \`\_<sub>eq</sub>\_<sub>()</sub>\`, etc., based on the class attributes. This saves you from having to write these methods yourself. Additionally, data classes promote immutability, meaning their attributes are typically declared as \`read-only\`, which prevents accidental modification of the data.

> With Python’s property(), you can create managed attributes in your classes. You can use managed attributes, also known as properties, when you need to modify their internal implementation without changing the public API of the class. Providing stable APIs can help you avoid breaking your users’ code when they rely on your classes and objects. &#x2014; [RealPython](https://realpython.com/python-property/)

The `@property` decorator is used in Python to transform a method into a read-only attribute. It allows you to define a method that behaves like an attribute, so you can access it without using parentheses, as if it were a regular attribute.

When the `@property` decorator is applied to a method within a class, it converts the method into a "getter" method. This means that when the property is accessed, the method is automatically called and its return value is returned instead. Essentially, `@property` enables you to define a method that can be accessed like an attribute, providing a more user-friendly and intuitive interface.

Syntax: `property(fget=None, fset=None, fdel=None, doc=None)`

• fget: function to return the value of the managed attribute
• fget: function to set the value of the managed attribute
• fdel: function to handle managed attribute deletion

• doc: string representing the property's docstring

  class Circle: def __init__{(self, radius)}: self._radius = radius

  @property def radius(self): return self._radius

  @property def area(self): return 3.14 * (self._radius ** 2)

In the code above, the `radius` method is decorated with `@property`, transforming it into a property. Now, instead of accessing the radius as `circle.radius()`, you can simply access it as `circle.radius`. Similarly, the `area` method is decorated with `@property` too, allowing you to access it as `circle.area`.

Note that `@property` is typically used with getter methods, but not restricted to them. You can also define `setter` and `deleter` methods for a property using additional decorators - `@<property<sub>name</sub>>.setter` and `@<property<sub>name</sub>>.deleter`, respectively. These are used to modify the value of the property or delete it, providing more control and encapsulation for managing attributes within a class.

• RealPython

The `@staticmethod` decorator in Python is used to define a static method within a class. A static method is a method that belongs to the class itself rather than an instance of the class. This decorator allows a method to be called on the class directly, without creating an instance of the class.

When a method is defined as a static method using the `@staticmethod` decorator, it does not receive any attributes related to the class or the instance (such as `self` in regular instance methods). Instead, it behaves similarly to a regular function, receiving only the arguments passed to it.

Static methods are typically used when a method does not require access to instance-specific or class-specific data and can be called directly on the class itself. These methods provide utility-like behavior, which is independent of any specific instance or state of the class.

The `@classmethod` decorator in Python is used to define a class method within a class. A class method is a method that is bound to the class rather than an instance of the class. It receives the class itself as the first argument, conventionally named `cls`, instead of the instance itself for regular methods.

The `@classmethod` decorator allows a method to be called on the class directly, without creating an instance of the class. This can be useful for methods that need to access or manipulate class-specific data, without requiring access to instance-specific data.

When a method is defined as a class method using the `@classmethod` decorator, it receives the class as the first argument, allowing it to access and modify class-level variables or invoke other class methods. Class methods can also create new instance objects of the class if needed.

Class methods are often used for alternative constructors or factory methods, where they provide a way to create instances of a class with different initialization parameters or setups, without having to rely solely on the primary constructor.

In summary, the `@classmethod` decorator is used to define a method that operates on the class itself rather than an instance. It provides a way to manipulate class-specific data and create alternative constructors or factory methods.

• attributes are variables that belong to a class. Unlike class attributes, you can’t access instance attributes through the class. You need to access them through their containing instance.
• methods are functions that belong to a class.
• class.__init__: The constructor of a class. Self is used to refer to the instance of the class.
• class.attribute: A variable that is shared by all instances of a class.
• In general, you should use class attributes for sharing data between instances of a class. Any changes on a class attribute will be visible to all the instances of that class.
• leading with an underscore: A convention to indicate that the attribute or method is intended to be private.
• leading with two underscores: mangles the name and prevents use from outside the class
• __str__: A special method that is called when an instance of a class is printed. Use to give a friendly name.
• @classmethod: A function that is defined inside a class and is used to modify the state of an instance. A class method receives the class as an implicit first argument, just like an instance method receives the instance.
• @staticmethod: A method that is bound to a class rather than its object. A static method does not receive an implicit first argument. A static method is also a method that is bound to the class and not the object of the class. This method can’t access or modify the class state. It is present in a class because it makes sense for the method to be present in class.
• Use `isinstance()` to check if an object is an instance of a class.
• Use `issubclass()` to check if a class is a subclass of another class.
• vars() returns the dict attribute of the given object.
• Property and Descriptor Based Attributes:
  • https://realpython.com/python-classes/#property-and-descriptor-based-attributes

• Use `field` with `default<sub>factory</sub>` to create a mutable default value.
• Data class decorator takes the following parameters:
  • init: Add .__init_₍₎ method? (Default is True.)
  • repr: Add .__repr_₍₎ method? (Default is True.)
  • eq: Add .__eq_₍₎ method? (Default is True.)
  • order: Add ordering methods? (Default is False.)
  • unsafe_hash: Force the addition of a .__hash_₍₎ method? (Default is False.)
  • frozen: If True, assigning to fields raise an exception. (Default is False.)
• class.__postinit_₍₎ is called after the init method.
• Field support the types: int, float, str, bytes, bool, tuple, list, dict, set, frozenset, array, datetime, uuid
• Field supports the following parameters:
  • default: Default value of the field
  • default_factory: Function that returns the initial value of the field
  • init: Use field in .__init_₍₎ method? (Default is True.)
  • repr: Use field in repr of the object? (Default is True.)
  • compare: Include the field in comparisons? (Default is True.)
  • hash: Include the field when calculating hash()? (Default is to use the same as for compare.)
  • metadata: A mapping with information about the field

• Create tuple >>> t = (1, 2, 3)
• Concatenate two tuples >>> t + (4, 5, 6)
• Multiply a tuple >>> t * 2

• Unpacking tuple >>> a, b, *c = t

  • If the asterisk is added to another variable name than the last, Python will assign values to the variable until

  the number of values left matches the number of variables left.

• delete tuple >>> del t
• Tuple methods:
  • count: Returns the number of times a specified value occurs in a tuple.
  • index: Searches the tuple for a specified value and returns the position of where it was found.