Constructors

 Constructors

Used to create and initialize an object of a class with or without starting/initial values.

enemy = Enemy() # calling a constructor of the class Enemy() -> This keyword.

Different types of Constructors:

  • Default/ Empty Constructors - enemy = Enemy()
  • No Argument Constructors - enemy = Enemy()
  • Parameter Constructors - enemy = Enemy(typeOfEnemy="Dragon")
Enemy.py
# file to define enemy class

class Enemy:
    # If you have constructors with parameters then you don't need to
    # define attributes exclusively in class.
    # typeOfEnemy: str
    # healthPoints: int = 10
    # attack_damage: int = 1
   
    # This constructor will be created by python automatically if we do not define it.
    # But we are defining it here to show that we can create a constructor
    # with no parameters.
    # Can force it to do nothing.
    # It will get activated when we create an instance of the class.
    # like -> enemy = Enemy()
    """
    def __init__(self):  # self refers to the current instance of the class
        # Default or empty constructor
        # which is defined by us but will not perform any task.
        pass # it means just bypass the constructor and do nothing.
   
    # No Argument Constructor
    def __init__(self):
        print('New enemy created! with no inital values.')
   
    """
    # Parameterized Constructor
    def __init__(self, typeOfEnemy: str,
                healthPoints: int = 10, attack_damage: int = 1):
        self.typeOfEnemy = typeOfEnemy
        self.healthPoints = healthPoints
        self.attack_damage = attack_damage
        print(f'New enemy created! Type: {self.typeOfEnemy},
        Health: {self.healthPoints}, Attack Damage: {self.attack_damage}')

    def talk(self):
        print(f"I am a {self.typeOfEnemy}. Be prepared to fight!")

    def walk_forward(self):
        print(f"{self.typeOfEnemy} moves closer to you!")

    def attack(self):
        print(f"{self.typeOfEnemy} attacks you for {self.attack_damage} damage!")

Main.py
# file to use enemy class file

from Enemy import Enemy

"""
enemy = Enemy() # calling a constructor of the class Enemy() -> This keyword.

# print(enemy.typeOfEnemy) this part of code will fail
# as no value is assigned in class for this attribute.

enemy.typeOfEnemy = "Goblin"  # Assigning a value to the typeOfEnemy attribute
enemy.talk() # This will call the talk method from the Enemy class
enemy.walk_forward() # This will call the walk_forward method from the Enemy class
enemy.attack() # This will call the attack method from the Enemy class
print(enemy.typeOfEnemy) # now it will work.
print(enemy.healthPoints)
print(enemy.attack_damage)
"""

enemy2 = Enemy(typeOfEnemy="Orc", healthPoints=20, attack_damage=5) # Creating another
instance of the Enemy class with parameters
enemy3 = Enemy(typeOfEnemy="Dragon") # Creating another instance of the Enemy class
with parameters


Comments

Post a Comment

Popular posts from this blog

Post Request with Pydantic usage (input validator)

Image
Post Request by using Pydantic Pydantic Python library that is used for data modeling, data parsing and has efficient error handling. Pydantics is commonly used as a resource for data validation and how to handle data coming to our FastAPI application. Pydantic implementation mechanism Create a different request model for data validation Field data validation on each variable/element BaseModel is the Pydantics BaseModel class which will provide facility to validate data. Field is the keyword to do it. As it will help to provide constraints for data validation. sample class BookRequest(BaseModel):     id: int = Field(gt=0)     title: str = Field(min_length=3)     author: str = Field(min_length=1)     description: str = Field(min_length=1, max_length=100)     rating: int = Field(gt=0, lt=5) Book Request and Book Conversion We will convert the Pydantic Request into a Book Example for post request method @app.post("/create_book") async def c...
Read more

Code Scalability and Routing

Image
 Creating Authentication file As we need to keep authentication part separate from our main application working so that we will not mess-up with our main application logic and it's security settings and authentication criteria as well as logics. auth.py - Basic authentication code stub. # This file is to define authenticator and authorization for the Todo application. from fastapi import FastAPI , status app = FastAPI () @ app . get ( "/auth" , status_code = status . HTTP_200_OK ) async def get_user ():     return { 'user' : 'authenticated_user' } Create Routers Package Here we want to use both and auth.py and main.py file to run together and to allow routers to run smoothly and want to scale the project code. To make this possible we need to use router facility or FastAPI. Here we are going to have a main file is a route of our application and routes will sit on this main file and will help in performing the tasks on call from main file. To make i...
Read more

CRUD Assignment

Image
 CRUD Assignment 1. Create a new API Endpoint that can fetch all books from a specific author using either Path Parameters or Query Parameters. Code and Result: As async is implemented by FastAPI itself hence ignored it. from fastapi import FastAPI app = FastAPI () BOOKS = [         { "title" : "Book One" , "author" : "Author A" , "category" : "Fiction" },         { "title" : "Book Two" , "author" : "Author B" , "category" : "Non-Fiction" },         { "title" : "Book Three" , "author" : "Author A" , "category" : "Biography" },         { "title" : "Book Four" , "author" : "Author A" , "category" : "Historical" },         { "title" : "Book Five" , "author" : "Author A" , "category" : "Romanc...
Read more