Zen of Python

Python is a high-level, general-purpose programming language. Its design philosophy emphasizes code readability with the use of significant indentation.

Python is dynamically typed and garbage-collected. It supports multiple programming paradigms, including structured (particularly procedural), object-oriented and functional programming. It is often described as a "batteries included" language due to its comprehensive standard library.

Guido van Rossum began working on Python in the late 1980s as a successor to the ABC programming language and first released it in 1991 as Python 0.9.0. Python 2.0 was released in 2000. Python 3.0, released in 2008, was a major revision not completely backward-compatible with earlier versions. Python 2.7.18, released in 2020, was the last release of Python.

Python consistently ranks as one of the most popular programming languages, and has gained widespread use in the machine learning community.

 History:

Python was invented in the late 1980s  by Guido van Rossum at Centrum Wiskunde & Informatica (CWI) in the Netherlands as a successor to the ABC programming language, which was inspired by SETL, capable of exception handling and interfacing with the Amoeba operating system. Its implementation began in December 1989. Van Rossum shouldered sole responsibility for the project, as the lead developer, until 12 July 2018, when he announced his "permanent vacation" from his responsibilities as Python's "benevolent dictator for life" (BDFL), a title the Python community bestowed upon him to reflect his long-term commitment as the project's chief decision-maker  (he's since come out of retirement and is self-titled "BDFL-emeritus"). In January 2019, active Python core developers elected a five-member Steering Council to lead the project.

Python 2.0 was released on 16 October 2000, with many major new features such as list comprehensions, cycle-detecting garbage collection, reference counting, and Unicode support. Python 3.0 was released on 3 December 2008, with many of its major features backported to Python 2.6.x and 2.7.x. Releases of Python 3 include the 2to3 utility, which automates the translation of Python 2 code to Python 3.

Python 2.7's end-of-life was initially set for 2015, then postponed to 2020 out of concern that a large body of existing code could not easily be forward-ported to Python 3. No further security patches or other improvements will be released for it. Currently only 3.8 and later are supported (2023 security issues were fixed in e.g. 3.7.17, the final 3.7.x release). While Python 2.7 and older is officially unsupported, a different unofficial Python implementation, PyPy, continues to support Python 2, i.e. "2.7.18+" (plus 3.9 and 3.10), with the plus meaning (at least some) "backported security updates"

In 2021 (and again twice in 2022), security updates were expedited, since all Python versions were insecure (including 2.7) because of security issues leading to possible  remote code execution  and web-cache poisoning. In 2022, Python 3.10.4 and 3.9.12 were expedited  and 3.8.13, because of many security issues. When Python 3.9.13 was released in May 2022, it was announced that the 3.9 series (joining the older series 3.8 and 3.7) would only receive security fixes in the future. On 7 September 2022, four new releases were made due to a potential denial-of-service attack: 3.10.7, 3.9.14, 3.8.14, and 3.7.14.

Every Python release since 3.5 has added some syntax to the language. 3.10 added the | union type operator  and the match and case keywords (for structural pattern matching statements). 3.11 expanded exception handling functionality. Python 3.12 added the new keyword type.

Notable changes in 3.11 from 3.10 include increased program execution speed and improved error reporting. Python 3.11 claims to be between 10 and 60% faster than Python 3.10, and Python 3.12 adds another 5% on top of that. It also has improved error messages, and many other changes.

def check_number_format(number_str):
    """
    Check if the given number is in decimal or binary format.

    Args:
    - number_str (str): The number represented as a string.

    Returns:
    - str: Description of the number format ('Decimal' or 'Binary').
    """
    # Check if the number contains only binary digits (0 and 1)
    if all(char in '01' for char in number_str):
        return 'Binary'
    # Check if the number contains only decimal digits (0-9)
    elif number_str.isdigit():
        return 'Decimal'
    else:
        return 'Neither'

# Example usage
number_str = input("Enter the number: ")
result = check_number_format(number_str)
print(f"The number is {result}.")




def is_palindrome(number_str):
    """
    Check if the given number is a palindrome.

    Args:
    - number_str (str): The number represented as a string.

    Returns:
    - bool: True if the number is a palindrome, False otherwise.
    """
    return number_str == number_str[::-1]

def main():
    # Input from the user
    number_str = input("Enter a number: ")

    # Check if the input is a valid number
    if not number_str.isdigit():
        print("Please enter a valid number.")
        return

    # Check if the number is a palindrome
    if is_palindrome(number_str):
        print(f"{number_str} is a palindrome.")
    else:
        print(f"{number_str} is not a palindrome.")

# Run the main function
if __name__ == "__main__":
    main()

As of April 2024, Python 3.12 is the stable release, and 3.12 is the only version with active (as opposed to just security) support.

Since 27 June 2023, Python 3.8 is the oldest supported version of Python (albeit in the 'security support' phase), due to Python 3.7 reaching end-of-life.

Python 3.13 introduced an incremental garbage collector (producing shorter pauses for collection in programs with a lot of objects); an experimental JIT compiler; and removals from the C API. Some standard library modules and many deprecated classes, functions and methods, will be removed in Python 3.15 and/or 3.16.  Starting with 3.13, it and later versions have 2 years of full support (up from one and a half); followed by 3 years of security support (for same total support as before).




def calculator():
    print("Select operation:")
    print("1. Add")
    print("2. Subtract")
    print("3. Multiply")
    print("4. Divide")

    choice = input("Enter choice (1/2/3/4): ")

    num1 = float(input("Enter first number: "))
    num2 = float(input("Enter second number: "))

    if choice == '1':
        print(f"Result: {num1 + num2}")
    elif choice == '2':
        print(f"Result: {num1 - num2}")
    elif choice == '3':
        print(f"Result: {num1 * num2}")
    elif choice == '4':
        print(f"Result: {num1 / num2}")
    else:
        print("Invalid input")

calculator()

Design philosophy and features:

Python is a multi-paradigm programming language. It provides full support for object-oriented programming and structured programming. Many of its features also support functional programming and aspect-oriented programming (including metaprogramming and metaobjects).  Extensions allow Python to support many other paradigms such as design by contract[72][73] and logic programming.

Python relies on dynamic typing and combines reference counting with a cycle-detecting garbage collector to manage memory.  It employs dynamic name resolution (late binding) to link method and variable names as the program runs.

Its design has some support to program in the Lisp tradition. It includes filter, map, and reduce functions; list comprehensions, dictionaries, sets, and generator expressions.  The standard library contains two modules (itertools and functools) that put into action functional tools borrowed from Haskell and Standard ML. 

The main idea behind Python is summed up in the Zen of Python (PEP 20), which includes sayings like: 

• Beautiful tops ugly.

• Explicit beats implicit.

• Simple trumps complex.

• Complex is preferable to complicated.

• Easy-to-read matters.