Generators in Python

Generator expressions are very similar to list comprehensions. The main difference is that it does not create a full set of results at once; it creates a generator object which can then be iterated over.

For instance, see the difference in the following code:

List comprehension

[x**2 for x in range(10)]

# Output: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Generator comprehension

(x**2 for x in range(10))

# Output: <generator object <genexpr> at 0x11b4b7c80>

These are two very different objects:

the list comprehension returns a list object whereas the generator comprehension returns a generator.

generator objects cannot be indexed and makes use of the next function to get items in order.

Use cases

Generator expressions are lazily evaluated, which means that they generate and return each value only when the generator is iterated. This is often useful when iterating through large datasets, avoiding the need to create a duplicate of the dataset in memory:

for square in (x**2 for x in range(1000000)):

Example: Generator Function

def mygenerator():
    print('First item')
    yield 10

    print('Second item')
    yield 20

    print('Last item')
    yield 30

>>> gen = mygenerator() 
>>> next(gen) 
First item 
10                      
>>> next(gen) 
Second item 
20                      
>>> next(gen) 
Last item 
30

Comments

Is-A and Has-A relationships in python

In object-oriented programming, the concept of IS-A is a totally based on Inheritance, which can be of two types Class Inheritance or Interface Inheritance. It is just like saying "A is a B type of thing". For example, Apple is a Fruit, Car is a Vehicle etc. Inheritance is uni-directional. For example, House is a Building. But Building is not a House. #Is-A relationship --> By Inheritance class A: def __init__ ( self ): self .b= 10 def mym1 ( self ): print ( 'Parent method' ) class B(A): def mym2 ( self ): print ( 'Child method' ) d = B() d.mym1() #output: Parent method d.mym2() #output: Child method HAS-A Relationship: Composition(HAS-A) simply mean the use of instance variables that are references to other objects. For example Maruti has Engine, or House has Bathroom. Let’s understand...

Inheritance and Types in Python

Inheritance Creating a new class from existing class is known as inheritance . The class from which features are inherited is known as base class and the class into which features are derived into is called derived class . Syntax: class derived- class (base class ): < class -suite> Inheritance promotes reusability of code by reusing already existing classes. Inheritance is used to implement is-a relationship between classes. Following hierarchy is an example representing inheritance between classes: Single inheritance When a derived class inherits only from syntax, the base class is called single inheritance. If it has one base class and one derived class it is called single inheritance. Diagram Syntax class A: #parent class #some code class b(A):...

Exception Handling in Python

Introduction An error is an abnormal condition that results in unexpected behavior of a program. Common kinds of errors are syntax errors and logical errors. Syntax errors arise due to poor understanding of the language. Logical errors arise due to poor understanding of the problem and its solution. Anomalies that occur at runtime are known as exceptions. Exceptions are of two types: synchronous exceptions and asynchronous exceptions. Synchronous exceptions are caused due to mistakes in the logic of the program and can be controlled. Asynchronous exceptions are caused due to hardware failure or operating system level failures and cannot be controlled. Examples of synchronous exceptions are: divide by zero, array index out of bounds, etc.) . Examples of asynchronous exceptions are: out of memory error, memory overflow, memory underflow, disk failure, etc. Overview of errors and exceptions in Python is as follows: Handling Exceptions Flowch...

sibi's_python_blog

Search This Blog