is used to retrieve as much possible information about the platform on which the program is being currently executed.

Purpose: Returns a string with a detailed description of the platform.

Description: This function gives you a complete summary of the platform you are running on, which includes information like OS name, release, version, and additional identifiers.

Purpose: Returns the machine type (architecture).

Description: This provides the hardware identifier of the machine, such as x86_64 for 64-bit Intel processors, arm for ARM-based systems, etc.

Purpose: Returns the name of the processor.

Description: This function returns the processor type of the machine you are working on. If the information is not available, it may return an empty string.

Purpose: Returns the name of the operating system.

Description: This function provides a simple way to check the underlying OS. The output might be Windows, Linux, Darwin (for macOS), etc.

Returns the version of the operating system.

Description: This function returns the version information of the current operating system.

Purpose: Returns the name of the Python implementation.

Description: This function tells you which Python interpreter is being used, such as CPython, PyPy, IronPython, etc

Purpose: Returns the Python version as a tuple.

Description: This function returns the current version of Python as a tuple, which is useful when you want to split the major, minor, and patch versions

This function returns a tuple that stores information regarding the system.

this function can be used to replace the individual functions to retrieve information about the system, node, release, version, machine, version and processor. Thus, a single function serving many purposes

This function returns a tuple that stores information about the python build date and build no. This information is stored in the tuple as a string datatype.

This function returns a tuple that stores information about the bit architecture(number of bits in the platform processor) and linkage format( defines how names can or can not refer to the same entity throughout the whole program or one single translation unit).

(like OS, hardware, and processor)

(like version and implementation)

are a fundamental aspect of Python programming that handle errors in code, preventing programs from crashing unexpectedly.

Raised when a file operation fails, such as trying to open a file that doesn’t exist.

is an event that occurs during the execution of a program and disrupts the normal flow of instructions.

Raised when trying to access an index that is not within the range of a list or other data structure.

are a type of error that occurs when a syntactically correct program runs into an unexpected situation.

Raised when a function receives an argument of the right type but an inappropriate value.

In this case, when Python encounters the division by zero, it does not crash. Instead, it catches the error and executes the code in the except block, printing the error message.

is used to specify code that should run no matter what happens, whether an exception is raised or not.

This is useful for cleanup operations, such as closing files or releasing resources.

This is useful in situations where you need to guarantee that certain cleanup code runs, such as closing a file or a database connection.

This is useful when different exceptions should be handled similarly.

is executed if the try block does not raise an exception.

used to handle the normal case where no exceptions occur.

helps in separating the error handling code from the normal operation of the program.

This allows for more granular control over how exceptions are handled, particularly in cases where some errors should be handled differently depending on the context.

allows you to define your own exceptions by creating a new class that inherits from the built-in Exception class.

This can be useful in specific cases where you want to handle errors more granularly

perform some actions, and then re-raise the exception so it can be handled elsewhere.

is raised inside a function and is not caught, it propagates upwards to the calling function.

This process continues until the exception is caught or until it reaches the top of the call stack, at which point the program crashes.

if an exception occurs in divide, it will propagate up to get_input, and if get_input doesn’t handle it, it will propagate to the main code block.

128 basic characters, including letters, numbers, and symbols.

is historically crucial as it laid the foundation for later encoding standards.

Represents thousands of characters across languages,each with a unique hexadecimal code point.

allows representing thousands of characters from various languages and symbol.

represent unique Unicode values.

balancing storage efficiency with the ability to represent diverse characters.

A popular Unicode encoding that uses 1-4 bytes per character, efficient for global text.

allow using special characters in strings.

Include special characters in strings, like ‘\n’ for newline or ‘\t’ for tab.

converts a single character to its Unicode code as an integer

Gets Unicode codepoint of a character.

Gets character from a Unicode codepoint.

it is converts an integer codepoint to its corresponding character.

are defined with single (‘) or double (“) quotes. Multi-line strings use triple quotes (‘’’ ‘’’ ) and preserve formatting, ideal for documentation and formatted text.

string in Python are ordered

Strings are ordered, starting from index 0; negative indices access from the end.

allows extracting substrings using start and end indices, with the end index exclusive.

Looping through strings can use enumerate for index and character, or list comprehensions for transformations.

they cannot be altered after creation.

Using enumerate with a for loop gives both index and character.

Checks on each character, maintaining readability.

each character in a string can be accessed individually using a for loop.

to handling text data is foundational for programming

are essential for almost every type of application, from data processing to user interactions