Python

Python is a high-level, interpreted, interactive and object-oriented scripting language. Python is dynamically typed and suited to object orientated programming.

• Various data types are available: numbers (floating point, complex, and unlimited-length long integers), strings (both ASCII and Unicode), lists, and dictionaries.
• Data types are strongly and dynamically typed. Mixing incompatible types (e.g. attempting to add a string and a number) causes an exception to be raised, so errors are caught sooner.
• Object-oriented programming with classes and multiple inheritance.
• Raising and catching exceptions, resulting in cleaner error handling.
• Python contains advanced programming features such as generators and list comprehensions.
• Code can be grouped into modules and packages.
• Comes with a large standard library that supports many common programming tasks such as connecting to web servers, searching text with regular expressions, reading and modifying files
• Python's interactive mode makes it easy to test short snippets of code. There's also a bundled development environment called IDLE
• It's easily extended by adding new modules implemented in a compiled language such as C or C++
• It can also be embedded into an application to provide a programmable interface.
• Automatic memory management frees you from having to manually allocate and free memory in your code.

Tuples have structure, lists have order. Lists are mutable; tuples are not.

• A shallow copy constructs a new compound object and then (to the extent possible) inserts references into it to the objects found in the original.
• A deep copy constructs a new compound object and then, recursively, inserts copies into it of the objects found in the original.

• Python has a multi-threading package but if you want to multi-thread to speed your code up, then it’s usually not a good idea to use it.
• Python has a construct called the Global Interpreter Lock (GIL). The GIL makes sure that only one of your ‘threads’ can execute at any one time. A thread acquires the GIL, does a little work, then passes the GIL onto the next thread.
• This happens very quickly so to the human eye it may seem like your threads are executing in parallel, but they are really just taking turns using the same CPU core.
• All this GIL passing adds overhead to execution. This means that if you want to make your code run faster then using the threading package often isn’t a good idea.

The compiling and linking allows the new extensions to be compiled properly without any error and the linking can be done only when it passes the compiled procedure. If the dynamic loading is used then it depends on the style that is being provided with the system. The python interpreter can be used to provide the dynamic loading of the configuration setup files and will rebuild the interpreter.
The steps that are required in this as:

• Create a file with any name and in any language that is supported by the compiler of your system. For example file.c or file.cpp
• Place this file in the Modules/ directory of the distribution which is getting used.
• Add a line in the file Setup.local that is present in the Modules/ directory.
• Run the file using spam file.o
• After a successful run of this rebuild the interpreter by using the make command on the top-level directory.
• If the file is changed then run rebuildMakefile by using the command as ‘make Makefile’.

The Ternary operator is the operator that is used to show the conditional statements. This consists of the true or false values with a statement that has to be evaluated for it.
Blueprint:

condition_if_true if condition else condition_if_false

Example:

is_nice = Truestate = "nice" if is_nice else "not nice"

The built-in datatypes in Python is called dictionary. It defines one-to-one relationship between keys and values. Dictionaries contain pair of keys and their corresponding values. Dictionaries are indexed by keys.

A MonkeyPatch is a piece of Python code which extends or modifies other code at runtime (typically at startup).

We use *args when we aren't sure how many arguments are going to be passed to a function, or if we want to pass a stored list or tuple of arguments to a function. **kwargsis used when we don't know how many keyword arguments will be passed to a function, or it can be used to pass the values of a dictionary as keyword arguments. The identifiers args and kwargs are a convention, you could also use *bob and **billy but that would not be wise.