Page Contents
What is an Object ?
Object is the most basic concept and a key to understand the Object-Oriented programming . Object is an entity that has two characteristics , State and Behavior . Some examples of real world object can be : Bike , Chair , Dog etc. Lets take an example of a Bike . Bike has some state ( current gear , current speed ) and behavior ( change gear , apply brake ) .
One way to begin thinking in an object-oriented way is to identify the state and behavior of real world objects . Software objects are also similar to the real world objects. They too contains State and Behavior . An Object stores its state in fields and exposes the behavior through methods.
What is Class ?
Class is a blueprint from which objects of same type can be created . Lets take an example of a Bike again . There are thousands of bikes with the same characteristics i.e having same make and model . They are created from the same prototype / blueprint called class.
Here’s a simple example in Python:
Example: Employee Class in python
# Define the class class Employee: def __init__(self, name, age, city): self.name = name self.age = age self.city = city def __str__(self): return f"Name= {self.name}, Age= {self.age}, City= {self.city}" # Create instance of the class emp1 = Employee("Shivaay", 6, "Haridwar") # Print the instance name. print(emp1.name) # Print the instance age. print(emp1.age) # Print the instance city. print(emp1.city) # Print the instance print(emp1) # Output Shivaay 6 Haridwar Name= Shivaay, Age= 6, City= Haridwar
In the above example code:
- The
Employee
class has an__init__
method that initializes the attributesname
,age
, andcity
when an instance of the class is created. - The
__str__
method returns a string representation of the object. - An instance
emp1
of theEmployee
class is created with different values. - When
print(emp1)
is called, Python implicitly calls the__str__
method to convert the object to string, and the string representation is printed to the console.
What if we don’t define __str__
method ?
If you don’t define the __str__
method in your class, Python will use the default implementation provided by the base object
class. This default implementation returns a string that includes the class name and the memory address of the object in hexadecimal format.
Here’s how the class would behave without explicitly defining the __str__
method:
class Employee: def __init__(self, name, age, city): self.name = name self.age = age self.city = city # Create an instance of the class emp = Employee("John", 30, "New York") # Print the instance print(emp) # Output <__main__.Employee object at 0x000001DFE0DED370>
In this case:
- The
Employee
class does not define a custom__str__
method. - When you print the
emp
instance, Python uses the default__str__
method from the baseobject
class, which returns a string containing the class name (Employee
) and the memory address where the object is stored in hexadecimal format.
Defining a custom __str__
method allows you to provide a more informative and readable representation of your objects.
What is __init__
method in Python ?
__init__
is a special method in Python classes. It stands for “initialize” and is also known as the constructor method. When you create an instance of a class, the __init__
method is automatically called. Its primary purpose is to initialize the object’s attributes.
Here’s a basic explanation of how __init__
works:
- When you create an object of a class, Python automatically calls the
__init__
method of that class. - The
__init__
method can take parameters, allowing you to pass initial values to the object’s attributes during creation. - Inside
__init__
, you typically set up the initial state of the object by assigning values to its attributes using theself
keyword. - The
self
parameter represents the instance of the class and allows you to access the attributes and methods of the object within the class. - You can also perform other initialization tasks within
__init__
, such as opening files, establishing connections, or performing calculations.
The self
Parameter in python class
In Python, self
is a conventionally used parameter name in instance methods of a class. It represents the instance of the class (i.e., the object) itself. When you call a method on an object, Python automatically passes the object itself as the first parameter to the method. This parameter is traditionally named self
, although you can technically name it anything you like, but sticking with self
is a widely accepted convention and makes your code more readable for others familiar with Python.
Here’s how self
works in Python classes:
- When you define a method within a class, you must include
self
as the first parameter of the method definition. - When you call a method on an object, Python automatically passes the object itself as the
self
parameter to the method. - Inside the method, you can access the attributes and methods of the object using the
self
keyword.
Here’s a simple example to illustrate the usage of self
:
class MyClass: def __init__(self, value): self.value = value # 'self' refers to the instance being created # Here 'value' is an instance variable. def print_value(self): print(self.value) # Accessing instance variable using 'self' # Creating an instance of MyClass obj = MyClass(10) # Calling a method on the object obj.print_value() # Output: 10
In this example:
- In the
__init__
method,self
refers to the instance ofMyClass
being created.self.value
refers to thevalue
attribute of that instance. - In the
print_value
method,self
again refers to the instance ofMyClass
.self.value
accesses thevalue
attribute of that instance. - When calling the
print_value
method on theobj
object, Python automatically passesobj
as theself
parameter to the method.
Modifying Object Properties
You can modify properties on objects like this:
class Employee: def __init__(self, name, age, city): self.name = name self.age = age self.city = city def __str__(self): return f"Name= {self.name}, Age= {self.age}, City= {self.city}" # Creating an Object of class Employee. emp1 = Employee("Shivaay", 6, "Haridwar") print(emp1.name) emp1.name = "Shvaay Singh Chauhan" print(emp1.name) # Output Shivaay Shvaay Singh Chauhan
Deleting Object Properties
You can delete properties on objects by using the del
keyword:
class Employee: def __init__(self, name, age, city): self.name = name self.age = age self.city = city def __str__(self): return f"Name= {self.name}, Age= {self.age}, City= {self.city}" # Creating an Object of class Employee. emp1 = Employee("Shivaay", 6, "Haridwar") print(emp1.age) # Deleting object property. del emp1.age print(emp1.age) # Output AttributeError: 'Employee' object has no attribute 'age'
you can delete the emp1 object as below
del emp1 print(emp1) # Output NameError: name 'emp1' is not defined
The pass
Statement
In functions, the pass
statement serves as a placeholder when you define a function but don’t want to implement its functionality yet. It allows you to create a valid function structure without any code inside its body.
Here’s how you can use pass
in a function:
def my_function(): pass my_function()
In this example:
- We define a function called
my_function
. - Inside the function body, we use the
pass
statement, which means that the function does nothing when called. - When you call
my_function()
, it will execute without any errors, but it won’t perform any actions.
The pass
statement is particularly useful in scenarios where you’re designing the structure of your program and need to define functions that will be implemented later. It helps in maintaining the syntactic correctness of your code without having to provide the implementation details immediately.