Blog

Python was developed by Guido van Rossum (a Dutch programmer) in the late 1980s and early nineties at the National Research Institute for Mathematics and Computer Science in the Netherlands.

Python is derived from many other languages, including ABC, Modula-3, C, C++, Algol-68, SmallTalk, and Unix shell and other scripting languages. Guido van Rossum wanted Python to be a high-level language that was powerful yet readable and easy to use.

Python is copyrighted. Like Perl, Python source code is now available under the GNU General Public License (GPL).

For many uninitiated people, the word Python is related to a species of snake. Rossum though attributes the choice of the name Python to a popular comedy series Monty Python’s Flying Circus on BBC.

Being the principal architect of Python, the developer community conferred upon him the title of Benevolent Dictator for Life (BDFL). However, in 2018, Rossum relinquished the title. Thereafter, the development and distribution of the reference implementation of Python is handled by a nonprofit organization Python Software Foundation.

Who Invented Python?

Python was invented by a Dutch Programmer Guido Van Rossum in the late 1980s. He began working on Python in December 1989 as a hobby project while working at the Centrum Wiskunde & Informatica (CWI) in the Netherlands. Python’s first version (0.9.0) was released in 1991.

Evolution of Python The Major Python Versions

Following are the important stages in the history of Python −

Python 0.9.0

Python’s first published version is 0.9. It was released in February 1991. It consisted of features such as classes with inheritance, exception handling, and core data types like lists and dictionaries..

Python 1.0

In January 1994, version 1.0 was released, armed with functional programming tools, features like support for complex numbers etc and module system which allows a better code organization and reuse.

Python 2.0

Next major version − Python 2.0 was launched in October 2000. Many new features such as list comprehension, garbage collection and Unicode support were included with it. Throughout the 2000s, Python 2.x became the dominant version, gaining traction in industries ranging from web development to scientific research. Various useful libraries like like NumPy, SciPy, and Django were also developed.

Python 3.0

Python 3.0, a completely revamped version of Python was released in December 2008. The primary objective of this revamp was to remove a lot of discrepancies that had crept in Python 2.x versions. Python 3 was backported to Python 2.6. It also included a utility named as python2to3 to facilitate automatic translation of Python 2 code to Python 3. Python 3 provided new syntax, unicode support and Improved integer division.

EOL for Python 2.x

Even after the release of Python 3, Python Software Foundation continued to support the Python 2 branch with incremental micro versions till 2019. However, it decided to discontinue the support by the end of year 2020, at which time Python 2.7.17 was the last version in the branch.

Current Version of Python

Meanwhile, more and more features have been incorporated into Python’s 3.x branch. As of date, Python 3.11.2 is the current stable version, released in February 2023.

What’s New in Python 3.11?

One of the most important features of Python’s version 3.11 is the significant improvement in speed. According to Python’s official documentation, this version is faster than the previous version (3.10) by up to 60%. It also states that the standard benchmark suite shows a 25% faster execution rate.

• Python 3.11 has a better exception messaging. Instead of generating a long traceback on the occurrence of an exception, we now get the exact expression causing the error.
• As per the recommendations of PEP 678, the add_note() method is added to the BaseException class. You can call this method inside the except clause and pass a custom error message.
• It also adds the cbroot() function in the maths module. It returns the cube root of a given number.
• A new module tomllib is added in the standard library. TOML (Tom’s Obvious Minimal Language) can be parsed with tomlib module function.

Python in the Future

Python is evolving everyday where Python 3.x receiving regular updates. Python’s developers community is focusing on performance improvements making it more efficient while retaining its ease of use.

Python is being heavily used for machine learning, AI, and data science, so for sure its future remains bright. It’s role in these rapidly growing fields ensures that Python will stay relevant for years.

Python is also increasingly becoming the first programming language taught in schools and universities worldwide, solidifying its place in the tech landscape.

Frequently Asked Questions About Python History

1. Who created Python?

Python created by Guido Van Rossum, a Dutch Programmer.

2. Why Python is called Python?

Python does not have any relation to Snake. The name of the Python programming language was inspired by a British Comedy Group Monty Python.

3. When was Python’s first version released?

Python’s first version was released in February 1991.

4. What was the first version of Python?

Python’s first version was Python 0.9.0

5. When was Python 3.0 version released?

Python 3.0 version was released in December 2008.

in Python allows you to manipulate functions for increasing the flexibility and re-usability of your code. You can create higher-order functions using nested scopes or callable objects.

Additionally, the functools module provides utilities for working with higher-order functions, making it easier to create decorators and other function-manipulating constructs. This tutorial will explore the concept of higher-order functions in Python and demonstrate how to create them.

What is a Higher-Order Function?

A higher-order function is a function that either, takes one or more functions as arguments or returns a function as its result. Below you can observe the some of the properties of the higher-order function in Python −

• A function can be stored in a variable.
• A function can be passed as a parameter to another function.
• A high order functions can be stored in the form of lists, hash tables, etc.
• Function can be returned from a function.

To create higher-order function in Python you can use nested scopes or callable objects. Below we will discuss about them briefly.

Advertisement

Creating Higher Order Function with Nested Scopes

One way to defining a higher-order function in Python is by using nested scopes. This involves defining a function within another function and returns the inner function.

Example

Let’s observe following example for creating a higher order function in Python. In this example, the multiplier function takes one argument, a, and returns another function multiply, which calculates the value a * b

defmultiplier(a):# Nested function with second number   defmultiply(b):# Multiplication of two numbers  return a * b 
   return multiply   

# Assigning nested multiply function to a variable  
multiply_second_number = multiplier(5)# Using variable as high order function  
Result = multiply_second_number(10)# Printing result  print("Multiplication of Two numbers is: ", Result)

Output

On executing the above program, you will get the following results −

Multiplication of Two numbers is:  50

Creating Higher-Order Functions with Callable Objects

Another approach to create higher-order functions is by using callable objects. This involves defining a class with a __call__ method.

Example

Here is the another approach to creating higher-order functions is using callable objects.

classMultiplier:def__init__(self, factor):
  self.factor = factor
   def__call__(self, x):return self.factor * x
 
# Create an instance of the Multiplier class
multiply_second_number = Multiplier(2)# Call the  Multiplier object to computes factor * x
Result = multiply_second_number(100)# Printing result  print("Multiplication of Two numbers is: ", Result)

Output

On executing the above program, you will get the following results −

Multiplication of Two numbers is:  200

Higher-order functions with the ‘functools’ Module

The functools module provides higher-order functions that act on or return other functions. Any callable object can be treated as a function for the purposes of this module.

Working with Higher-order functions using the wraps()

In this example, my_decorator is a higher-order function that modifies the behavior of invite function using the functools.wraps() function.

import functools

defmy_decorator(f):@functools.wraps(f)defwrapper(*args,**kwargs):print("Calling", f.__name__)return f(*args,**kwargs)return wrapper

@my_decoratordefinvite(name):print(f"Welcome to, {name}!")

invite("Tutorialspoint")

Output

On executing the above program, you will get the following results −

Calling invite
Welcome to, Tutorialspoint!

Working with Higher-order functions using the partial()

The partial() function of the functools module is used to create a callable ‘partial’ object. This object itself behaves like a function. The partial() function receives another function as argument and freezes some portion of a functions arguments resulting in a new object with a simplified signature.

Example

In following example, a user defined function myfunction() is used as argument to a partial function by setting default value on one of the arguments of original function.

import functools
defmyfunction(a,b):return a*b

partfunction = functools.partial(myfunction,b =10)print(partfunction(10))

Output

On executing the above program, you will get the following results −

100

Working with Higher-order functions using the reduce()

Similar to the above approach the functools module provides the reduce() function, that receives two arguments, a function and an iterable. And, it returns a single value. The argument function is applied cumulatively two arguments in the list from left to right. Result of the function in first call becomes first argument and third item in list becomes second. This is repeated till list is exhausted.

Example

import functools
defmult(x,y):return x*y

# Define a number to calculate factorial
n =4
num = functools.reduce(mult,range(1, n+1))print(f'Factorial of {n}: ',num)

Output

On executing the above program, you will get the following results −

Factorial of 4:  24