Why Python Stands out !!

Python is one of the most loved programming languages, not just because of its simplicity, but also due to its powerful and unique features. Whether you’re a beginner or a seasoned developer, Python offers elegant ways to solve problems. Let’s dive into some of Python’s standout features that set it apart from other languages

1. Dynamic Typing & Duck Typing

But, First of all, what is Dynamic and Duck typing !! In Dynamic typing, type-checking is performed at runtime. For example, Python is a dynamically typed language. It means that the type of a variable is allowed to change over its lifetime. Other dynamically typed languages are Perl, Ruby, PHP, Javascript, etc.

## variable a is assigned to a string 
a ="hello"
print(type(a)) 

## variable a is assigned to an integer 
a = 5
print(type(a))

In Duck typing, where the type or the class of an object is less important than the method it defines. Using Duck Typing, we do not check types at all. Instead, we check for the presence of a given method or attribute.

def quack(animal):
    animal.quack()

class Duck:
    def quack(self):
        print("Quack!")

class Robot:
    def quack(self):
        print("Robotic Quack!")

quack(Duck())  # Quack!
quack(Robot())  # Robotic Quack!

2. Multiple Assignments & Unpacking

In Multiple Assignments, the number of variables on the left side of the assignments operator(=) must match the number of values on the right side. and to separate the values, use comma(,)

a, b, c = 1, 2, 3  # Assign multiple values in one line
x, y = y, x  # Swap variables without a temporary variable

In Python, it is possible to unpack the elements of list/tuple/dictionary into distinct variables. Since values appear within lists/tuples in a specific order, they are unpacked into variables in the same order

def get_coordinates():
    return (42.3, -71.2)

latitude, longitude = get_coordinates()
print(latitude, longitude)  # 42.3 -71.2

3. List Comprehensions & Generator Expressions

It is an elegant way of defining and creating a list. List Comprehension allows us to create a list using for loop with lesser code. What normally takes 3–4 lines of code, can be compressed into just a single line.

# initializing the list 
list = [] 

for i in range(11): 
 if i % 2 == 0: 
  list.append(i) 

# print elements 
print(list)

Now, the same output can be derived from just a single line of code.

list = [i for i in range(11) if i % 2 == 0] 
print(list)

What are Generator Expressions?

Generator Expressions are somewhat similar to list comprehensions, but the former doesn’t construct list object. Instead of creating a list and keeping the whole sequence in the memory, the generator generates the next element in demand. When a normal function with a return statement is called, it terminates whenever it gets a return statement. But a function with a yield statement saves the state of the function and can be picked up from the same state, next time the function is called.

Syntax Difference: Parenthesis are used in place of square brackets.

# List Comprehension 
list_comprehension = [i for i in range(11) if i % 2 == 0] 

print(list_comprehension)

# Generator Expression 
generator_expression = (i for i in range(11) if i % 2 == 0) 

print(generator_expression)

So what’s the difference between Generator Expressions and List Comprehensions?
The generator yields one item at a time and generates item only when in demand. Whereas, in a list comprehension, Python reserves memory for the whole list. Thus we can say that the generator expressions are memory efficient than the lists.
We can see this in the example below.

# import getsizeof from sys module 
from sys import getsizeof 

comp = [i for i in range(10000)] 
gen = (i for i in range(10000)) 

#gives size for list comprehension 
x = getsizeof(comp) 
print("x = ", x) 

#gives size for generator expression 
y = getsizeof(gen) 
print("y = ", y)

OUTPUT:- 
x = 87624
y = 88

4 . First-Class Functions & Closures

First-class function is a concept where functions are treated as first-class citizens. By treating functions as first-class citizens, Python allows you to write more abstract, reusable, and modular code. This means that functions in such languages are treated like any other variable. They can be passed as arguments to other functions, returned as values from other functions, assigned to variables and stored in data structures.

Assigning Functions to Variables

We can assign a function to a variable and use the variable to call the function.

def msg(name):
    return f"Hello, {name}!"

# Assigning the function to a variable
f = msg

# Calling the function using the variable
print(f("Anurag"))

Passing Functions as Arguments

Functions can be passed as arguments to other functions

def msg(name):
    return f"Hello, {name}!"

def fun1(fun2, name):
    return fun2(name)

# Passing the greet function as an argument
print(fun1(msg, "Bob"))

Returning Functions from Other Functions

A function can return another function, allowing for the creation of function factories.

def fun1(msg):
    def fun2():
        return f"Message: {msg}"
    return fun2

# Getting the inner function
func = fun1("Hello, World!")
print(func())

Python Closures

In Python, a closure is a powerful concept that allows a function to remember and access variables from its lexical scope, even when the function is executed outside that scope. Closures are closely related to nested functions and are commonly used in functional programming, event handling and callbacks.

A closure is created when a function(the inner function) is defined within another function (the outer function) and the inner function references variables from the outer function. Closures are useful when you need a function to retain state across multiple calls, without using global variables.

def fun1(x):
  
    # This is the outer function that takes an argument 'x'
    def fun2(y):
      
        # This is the inner function that takes an argument 'y'
        return x + y  # 'x' is captured from the outer function
    
    return fun2  # Returning the inner function as a closure

# Create a closure by calling outer_function
closure = fun1(10)

# Now, we can use the closure, which "remembers" the value of 'x' as 10
print(closure(5))

How Closures Work Internally?

Closures in Python work by retaining access to variables from their enclosing function, even after the outer function has finished executing. This is possible because of how Python handles function scopes and stores references to variables instead of copying them.

5. Decorators: Python’s Superpower

In Python, decorators are a powerful and flexible way to modify or extend the behavior of functions or methods, without changing their actual code. A decorator is essentially a function that takes another function as an argument and returns a new function with enhanced functionality.

Decorators are often used in scenarios such as logging, authentication and memorization, allowing us to add additional functionality to existing functions or methods in a clean, reusable way.

def decorator(func):
    def wrapper():
        print("Before function call")
        func()
        print("After function call")
    return wrapper

@decorator
def say_hello():
    print("Hello, Python!")

say_hello()

6. Metaprogramming with Metaclasses

At first, the word Metaprogramming might sound complex and abstract, but if you’ve ever used decorators or metaclasses, you’ve already engaged in metaprogramming! In simple terms, metaprogramming is code that manipulates code.

In this section, we’ll explore metaclasses — what they are, when to use them, and possible alternatives. This is an advanced Python topic, and it’s recommended that you have a solid understanding of object-oriented programming before diving in.

Python treats classes as first-class objects, allowing dynamic class modifications at runtime using metaclasses.

class Meta(type):
    def __new__(cls, name, bases, dct):
        dct["created_by"] = "Python Metaclass"
        return super().__new__(cls, name, bases, dct)

class MyClass(metaclass=Meta):
    pass

print(MyClass.created_by)  # Python Metaclass

Conclusion

Python’s unique features make it a powerful and expressive language that is widely adopted across domains. Whether it’s dynamic typing, list comprehensions, or metaprogramming, Python consistently provides elegant solutions to common programming problems. What’s your favorite Python feature? Let’s discuss in the comments!