• The standard library of python supports network protocols, encoding as well as decoding of data (information) and also other networking concepts then it is less complex to implement network codes in Python better than C++.
• The Python gives two levels of access to network services. First is low level, you will get the fundamental socket support in the basic operating system (OS) that allows you to execute clients and servers for connection-oriented as well as connectionless protocols.
• Another one is high level; python are having libraries that give higher-level access to particular application-level network protocols like FTP, HTTP, etc.
• By using sockets in the code to connect to a remote machine or loopback address (127.0.01) is python network programming.

• Duck typing is the “type” of the object is a matter of concern only at runtime and you don’t require mentioning the type of the object before you execute any kind of operation on that object.
• Parts of the standard library in python suppose to use I/O like objects with read or write methods, yet you will pass anything that executes these, without having to inherit from anything.
• There is another idea in typing lark which is a characteristics of dynamic languages. This is known as duck typing.
• Example, in a statically typed language we have a concept of including. A few types of object can be included – typically only to objects of the similar type. Although most languages will let you a chance to add an integer to a floating point number – resulting in a floating point number. Attempt to include different types of objects together and the compiler will tell you that you’re not permitted.
• In Python we have to permit the object to describe what it to be included. The expression 4 + 4 is syntactic sugar for calling the __add__ method of the integer type. It is similar as calling int.__add__(4, 4). It means that if you define a __add__ method for one of your classes you will make all sorts of things happen when you include instances of them together.
• Many of Python syntax is sugar for underlying methods especially in data access. Accessing members of sequence type objects as well as mapping type objects is complete by using the __getitem__ method of these objects.

• The above code is exactly the same as :

• In Python ** is an exponential operator.The double asterisk form of **kwargs is used to pass a keyword, variable-length argument dictionary to a function. Again, the two asterisks (**) are the important element here, as the word kwargs is conventionally used, though not enforced by the language.
• Like *args, **kwargs get however several arguments you would like to supply into it. Though **kwargs differs from *args in that you will need to assign keywords.

• The symbol >>> is used to point out that what’s coming after is Python Code. It’s also known as Python Prompt.
• Likewise this is the prompt that appears in the Python Console interactive shell when you type python in the terminal. It indicates that you are in the python interactive shell and prepared to type python code.

• A decorator in Python is a function that takes another function as an argument, while not changing the function being used as an argument.
• Decorators dynamically alter the functionality of a function without using sub classes.
• This is useful when you want to extend the functionality of functions and don’t want to modify them.

• A wrapper is a python module that interface between python and another software library function which is a non python interface.
• Python wrapper allows users to write only python code, even when calling non python libraries.Decorators are also called ‘wrappers’.

• To pass the argument from my_function to wrapper the syntax is,

If you need more functions we do have something like:

But, your logic within the decorator should able to handle the args and kwargs generally.

• Python’s pickle module is a serialization (converting the object into streams of bytes) library which is used to serialize the python objects.That means it can be used to encode and decode your functions, classes, dict, list, string etc,.
• Two important methods that pickle module provides are `pickle.dumps` and `pickle.loads`.

• It is used for serializing and de-serializing a Python object structure. Any object in python can be pickled so that it can be saved on disk.
• What pickle does “serialises” the object before writing the file. Pickling is a way to convert a python object (list, dict, etc.) into a character stream.

• The flask is a web-development framework and it is one of the most-popular modules of python for web developers.
• It is easy to use, quick to learn, and easy to create applications. It uses template for html rendering.
• All though it is a micro-framework one can create medium level applications with this framework.
• Flask is a micro web framework developed in Python and it is based on the Werkzeug toolkit and Jinja2 template engine. It is Berkeley Software Distribution (BSD) licensed. Though, Flask supports extensions that include application features as if they were implemented in within the Flask.

• It is a light-weight process and they don’t require more memory overhead they are less expensive than processes.
• A thread has a starting, an execution sequence, and a conclusion. It has an instruction pointer that monitors where inside its context it is currently running.

• • It can be pre-interrupted.
  • It can temporarily be put on hold (also called sleeping) while other threads are running – this is known as yielding.

• The newer threading module included with Python 2.4 provides much more powerful, high-level support for threads than the thread module.
• A Python threading module exposes all the methods of the thread module and it will give several extra methods.

• • threading.activeCount() – It returns the number of thread objects that are active.
  • threading.currentThread() − It returns the number of thread objects in the caller’s thread control.
  • threading.enumerate() − It returns a list of all thread objects that are currently active.

• Additionally the methods, and thread module has thread class that implements threading. These methods provided by the Thread class are given below:

• • run() − This method is the entry point for a thread.
  • start() − This method starts a thread by calling the run method.
  • join([time]) − This waits for threads to terminate.
  • isAlive() − This method checks whether a thread is still executing.
  • getName() − This method returns the name of a thread.
  • setName() − This method sets the name of a thread.

• The union() method returns a new set with distinct elements from each and every one of the sets.
• The union of two or more sets is the set of all distinct elements shown in all the sets.

• • A = {1, 2}
  • B = {2, 3, 4}
  • C = {5}

Then,

• A∪B = B∪A ={1, 2, 3, 4}
• A∪C = C∪A ={1, 2, 5}
• B∪C = C∪B ={2, 3, 4, 5}
• A∪B∪C = {1, 2, 3, 4, 5}

• A super() indicates the immediate parent of actual class. Just like `self` which is not a keyword, but to access parent.
• Before `super`, the method was to explicitly use the type of master as specifier and to add `self` on function signature.

• • Allows us to avoid using base class explicitly
  • Working with Multiple Inheritance

• • These classes have all the same capabilities like as its parent, dict, but it extends the __setitem__ method to create log entries whenever a key is updated. After creating a log entry, method uses super() to delegate the work for essentially updating the dictionary with the key or value pair.
  • Before super() was presented, it have hardwired the call among dict.__setitem__(key, value and self). In any case, super() is improved since it is computed indirect reference.

• The Python range is a built-in function in Python which is very useful to generate sequences of numbers in the form of a list.
• The given end point is never part of the generated list.
• The range() function has two sets of parameters, as follows:
  • All parameters should be integers.
  • All parameters may be positive or negative
• Number of integers is to generate, beginning from zero. eg. range(4) == [0, 1, 2,3].

• In Python, __init__() method within a class is its constructor.Any method or variable that starts with double underscore is by default private.
• Python defines several standard private methods that have a special meaning, and __init__() is one of them. Some others are __str__(), __repr__(), __add__() and others.

• The __init__ function is known as a constructor, or initializer, and is automatically called when you create a new instance of a class. Within that function, the recently created object is assigned to the parameter “self”. The notation self.legs is an attribute called legs of the object in the variable self.

• The Python Def function is the User-Defined one.
• Function blocks start with the keyword def then followed by the function name and parentheses ( ( ) ).
• Any input parameters must place inside the parentheses. Now you can define parameters inside the parentheses.
• The initial statement of a function is optional statement – the documentation string of the function (docstring).
• Within the code block each and every function begins with (:) colon and is indented.
• The statement return [expression] exits the function, alternatively passing back the expression to caller. The return statement with no arguments is the similar as return none.

• The Python function is defined by a def statement. The syntax looks like this: def function-name (Parameter list): statements, i.e. the function body. The parameter list contains none or more parameters. Parameters are known as arguments, if the function is called.
• A python function is a “callable” (which just means something you can invoke) that repeats a set of steps that you pre-define.

• • Function blocks begin with the keyword def followed by the function name and parentheses ( ( ) ).
  • Any input parameters or arguments must be placed within these parentheses. Now you will define the parameters within the parentheses.
  • The initial statement of a function is optional – the documentation string of the function (docstring).
  • The code block within every function starts with a colon (:) and is indented.
  • The statement return [expression] exits a function, optionally passing back an expression to the caller. The return statement with no arguments is the similar as return none.

• Python is a scripting language like PHP, Perl, Ruby and so on. It can be used for web programming django, Google App Engine, Zope, and so on. But it can be used for desktop applications Blender 3D, or even for games pygame.

• 1. Machine Learning
  2. Data Science
  3. Web Application
  4. DevOps
  5. Process Automation
  6. Test Automation
  7. General purpose applications
  8. Information security
  9. Network security

• Byte code of Python is generated after compiling a python program.
• Python Byte code goes through two stages.
  • It compiles the code into .pyc files that is actually a bytecode. This .pyc file (bytecode) is interpreted by using CPython interpreter.
  • Its use for fast execution.

Python is a dynamic language, and running it from the command line basically triggers the given steps

• • The source is compiled first time it is encountered e.g., imported as a module or directly executed. This step generates a binary file, with a .pyc or .pyo extension depending on the system.
  • The interpreter reads the binary file and executes the opcodes one at a time.
  • The python interpreter is stack-based and once source is compiled corresponding .pyc is ready in the matching directory (in case of python 2.x). With python 3.x a new __pycache__ directory is produced for the source and all compiled Bytecode files are located underneath.

• Save the file as ‘MyProgram.py’. This ‘MyProgram.py’ is source code. Now if you compile this file you would get a file with ‘.pyc’ extention which is known as byte code.