Bytes

home

bytes

tutorials

python

constructors and generators in python

Constructors and Generators in Python

Module - 7 OOPs in Python
Constructors and Generators in Python

Overview

Constructors provide initial values for an object's attributes and are defined using the keyword 'init'. They're automatically called when an object is instantiated. Generators use the keyword 'yield' and can create iterators for efficient looping. Generators return an iterable set of items one at a time. Instead of returning all the items at once, a generator yields them one at a time, allowing efficient memory usage and improved performance.

Introduction to Constructors and Generators

Constructors initialize new objects and set their initial state. Generators produce sequences of values iteratively without explicitly defining each value.

What are Constructors?

Constructors are a special method explicitly used for creating and initializing class objects of a class ūü§Ē. When a new object is instantiated, the constructor method is automatically invoked in order to initialize the object's state properly ūüíĽ. Constructors serve several vital purposes. They can be used to set default values for an object's properties, enable objects to be initialized with different values at run-time ūüďÖ, and facilitate the inheritance of properties between classes ūüďö.

A constructor always has the same name as the class itself and does not have a return type ūüďĚ. Constructors can also accept parameters :123:, which can be used to pass in values for initializing the object's properties. For example, a "Student" class constructor might accept parameters for a student's name and grade level to create a new Student object with that information ūüďĚ. Objects without a constructor would have undefined property values by default, making them unusable.

Constructors ensure that objects are fully initialized with meaningful values as soon as they are created. They provide structure and consistency for objects in a class hierarchy and enable flexible object initialization that can support a variety of use cases ūüí°. Constructors are crucial for producing well-formed, properly instantiated objects in object-oriented programming languages ūüíĽ.

Different Types of Constructors

  1. Default Constructor:

Python creates a default constructor automatically if no constructor is defined explicitly. This constructor doesn't take any arguments and doesn't do anything except create an object of the class.

Here is an example of a default constructor:

class MyClass:
    def __init__(self):
        pass

obj = MyClass()

In the example above, MyClass has a default constructor, which doesn't do anything.

  1. Parameterized Constructor:

A parameterized constructor is a constructor that takes one or more arguments. This constructor is defined explicitly and can be used to initialize the class's instance variables.

Here is an example of a parameterized constructor:

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

obj = MyClass("John", 30)
print(obj.name) # Output: John
print(obj.age) # Output: 30

In the example above, MyClass has a parameterized constructor which takes two arguments, name and age, and initializes the instance variables name and age with the values passed as arguments.

What are Generators?

Generators are functions that enable programmers to pause and resume the execution of code. This capability allows for creating iterators, which can be leveraged to loop over data collections. Generators are a powerful and crucial tool for developing custom iterators and asynchronous programming in modern programming languages like JavaScript, Python, and others.

Generators are instrumental in developing custom iterators and asynchronous programming. They can also generate data sequences by yielding values from the generator function. Generators permit a function to pause its execution and return a value, then resume where it left off when next invoked. This ability to stop and restart function execution enables generators to act as iterators. They can traverse through a sequence, yielding one element at a time, and keep their place in the sequence for the next call.

The pausing and resuming functionality of generators is enabled through the yield keyword. When a yield statement is reached, the generator yields the specified value and pauses its execution. On the next call, the function resumes after the yield statement. This allows a generator to produce a sequence of values over multiple calls.

Generators are a powerful tool for developing efficient code that produces sequences or asynchronous behaviors. They enable custom iterators that can traverse collections or generate demand values. Asynchronous programming is also simplified using generators, as they can pause a function and wait for an asynchronous operation to complete before resuming. Generators enhance JavaScript, Python, and other languages with these valuable capabilities.

Different Types of Generators

  1. Generator Expressions: Generator expressions are a high-performance, memory-efficient generalization of list comprehensions and generators. They are used to create an iterator object written in a single line of code.
  2. Generator Functions: Generator functions are functions that use the yield keyword instead of the return keyword. They are written like a normal function but behave like an iterator, yielding one item at a time.
  3. Map and Filter Generators: Map and filter generators are special types of generators that can apply a function or filter to a sequence of elements.
  4. Coroutines: Coroutines are special types of generator functions that can both send and receive data. They are used to create more complex data pipelines.
  5. Itertools Generators: The itertools module contains a number of useful functions for creating iterators. These functions are all generators and can be used to create robust data pipelines.

Advantages and disadvantages of Using Constructors and Generators

Constructors Advantages:

  • Constructors can create objects of a specific type, enabling code reuse and consistency.
  • They are useful for setting default values for objects upon creation.
  • They provide a way to keep the code clean and organized.
  • Constructors can be complicated to write, debug and maintain.
  • Constructors can be misused, leading to code bloat and inefficiency.
  • If a constructor is incorrectly written, it can lead to unexpected behavior.

Generators Advantages:

  • Generators are useful for creating sequences of values.
  • They can be used to generate lazy sequences, reducing memory usage.
  • Generators are easy to write and can be composed together to create complex behaviors.
  • Generators can be hard to debug and maintain.
  • They can be slow if not used properly.
  • They can be challenging to understand for a beginner programmer.

Examples of Constructors and Generators

Constructors

# Constructors

class Person: 
    def __init__(self, name, age): 
        self.name = name 
        self.age = age 
  
# create objects of Person 
p1 = Person("John", 36) 
p2 = Person("Smith", 25)

The constructor takes two arguments, name, and age, and assigns them to instance variables. The instance variables can then be accessed and modified by other class methods.

# Generators 

def my_gen(): 
    n = 1
    print('This is printed first') 
    # Generator function contains yield statements 
    yield n 
  
    n += 1
    print('This is printed second') 
    yield n 
  
    n += 1
    print('This is printed at last') 
    yield n 

a = my_gen() 
next(a)

It contains yield statements that allow the function to return a sequence of values. The yield statement stops the function from executing further and returns the yielded value to the caller. When the function is called again, it resumes execution from the last yield statement.

Conclusion

Constructors are special methods used for initializing objects of a class. They set default values for object properties, enable objects to be initialized with different values at run-time, and facilitate inheritance. Generators are functions that create iterable sets of items one at a time and enable the creation of custom iterators for traversing collections of data. They can be leveraged to generate data sequences, pause and resume execution, and facilitate asynchronous programming.

Key takeaways

  1. Constructors are special types of functions used to create and initialize objects in Python.
  2. Generators are special types of functions used to generate new values on demand.
  3. Constructors and Generators are two powerful features of the Python programming language that allow for improved code readability and efficiency.
  4. Constructors create objects with specific properties and values, while generators create iterable sequences of values.
  5. Constructors and Generators can be used to create custom objects and sequences that can be used in any Python program.

Quiz

  1. Which of the following is a type of generator in Python? 
    1. Class 
    2. Iterator  
    3. Iterable 
    4. Sequence

Answer:b. Iterator

  1. What is a Generator in Python? 
    1. A sequence of values  
    2. A function that returns an object 
    3. An iterator that yields a sequence of values 
    4. An object that produces items one at a time

Answer:c. An iterator that yields a sequence of values

  1. What is a Constructor in Python? 
    1. A function that returns an object 
    2. An iterator that yields a sequence of values 
    3. An object that produces items one at a time  
    4. A special type of method used to initialize an object

Answer:d. A special type of method used to initialize an object

  1. What is the purpose of a Generator in Python? 
    1. To create an iterator 
    2. To produce a sequence of values  
    3. To initialize an object  
    4. To create a function

Answer:b. To produce a sequence of values

  1. What is the purpose of a Constructor in Python? 
    1. To create an iterator
    2. To produce a sequence of values 
    3. To initialize an object 
    4. To create a function

Answer:c. To initialize an object

Recommended Courses
Certification in Full Stack Data Science and AI
Course
20,000 people are doing this course
Become a job-ready Data Science professional in 30 weeks. Join the largest tech community in India. Pay only after you get a job above 5 LPA.
Masters in CS: Data Science and Artificial Intelligence
Course
20,000 people are doing this course
Join India's only Pay after placement Master's degree in Data Science. Get an assured job of 5 LPA and above. Accredited by ECTS and globally recognised in EU, US, Canada and 60+ countries.

AlmaBetter’s curriculum is the best curriculum available online. AlmaBetter’s program is engaging, comprehensive, and student-centered. If you are honestly interested in Data Science, you cannot ask for a better platform than AlmaBetter.

avatar
Kamya Malhotra
Statistical Analyst
Fast forward your career in tech with AlmaBetter

Vikash SrivastavaCo-founder & CPTO AlmaBetter

Vikas CTO

Related Tutorials to watch

Top Articles toRead

AlmaBetter
Made with heartin Bengaluru, India
  • Official Address
  • 4th floor, 133/2, Janardhan Towers, Residency Road, Bengaluru, Karnataka, 560025
  • Communication Address
  • 4th floor, 315 Work Avenue, Siddhivinayak Tower, 152, 1st Cross Rd., 1st Block, Koramangala, Bengaluru, Karnataka, 560034
  • Follow Us
  • facebookinstagramlinkedintwitteryoutubetelegram

© 2023 AlmaBetter