Examples and source code for this chapter are available in the GitHub repository in the chapter 2 folder: https://github.com/PacktPublishing/Mastering-Python-for-Networking-and-Security.

You will need some basic knowledge about command-execution in operating systems, and to install the Python distribution on your local machine.

Throughout this section, we'll explain the main modules you can find in Python for working with the Python interpreter, the operating system, and executing commands with the sub-procces module.

The sys module will allow us to interact with the interpreter and it contains most of the information related to the execution in progress, updated by the interpreter, as well as a series of functions and low-level objects.

sys.argv contains the list of parameters for executing a script. The first item in the list is the name of the script followed by the list of parameters.

We may, for example, want to parse command-line arguments at runtime. The sys.argv list contains all...

Throughout this section, we explain the main modules you can find in Python for working with the filesystem, accessing files and directories, reading and creating files, and operations with and without the context manager.

In this section, we review how we can work with the filesystem and perform tasks such as browsing directories or reading each file individually.

In some cases, it is necessary to iterate recursively through the main directory to discover new directories...

In this section, we are going to introduce the concept of threads and how we can manage them with Python modules.

Threads are streams that can be scheduled by the operating system and can be executed across a single core in a concurrent way or in parallel way across multiple cores. Threads can interact with shared resources, such as memory, and they can also modify things simultaneously or even in parallel.

There are two distinct types of threads:

• Kernel-level threads: Low-level threads, the user can not interact...

In this section, we are going to introduce the concepts of multithreading and concurrency and how we can manage them with python modules.

The idea behind multithreading applications is that they allow us to have copies of our code and execute them on additional threads. This allows a program to execute multiple operations simultaneously. In addition, when a process is blocked, for example to wait for input/output operations, the operating system can allocate computation time to other processes.

When we mention multiprocess processors, we're referring to a processor that can execute multiple threads simultaneously. These typically have two or more...

In this section, we review how we can use the socket.io module to create a webserver based in Python.

WebSockets is a technology that offers realtime communication between a client and server through a TCP connection, and eliminates the need for customers to be continually checking whether API endpoints have updates or new content. Clients create a single connection to a WebSocket server and remain pending to listen for new events or messages from the server.

The main advantage of websockets is that they are more efficient as they reduce the network load and send information to a large number of clients in the form of messages.

In this chapter, we learned about the main system modules for python programming, such as os for working with the operating system, sys for working with the filesystem, and sub-proccess for executing commands. We also reviewed how to work with the filesystem, reading and creating files, managing threads, and concurrency.

In the next chapter, we will explore the socket package for resolving IP addresses and domains, and implement client and servers with TCP and UDP protocols.

1. What is the main module that allows us to interact with the python interpreter?
2. What is the main module that allows us to interact with the OS environment, filesystem, and permissions?
3. What are the module and the method used to list the contents of the current working directory?
4. What is the module to execute a command or invoke a process via the call() function?
5. What is the approach that we can follow in python to handle files and manage exceptions in an easy and secure way?

6. What is the difference between processes and threads?
7. What are the main modules in python for creating and managing threads?
8. What is the limitation that python has when working with threads?
9. Which class provides a high-level interface for executing input/output tasks in an asynchronous way?
10. What is the function in the threading module that determines which thread has performed?

In these links, you will find more information about the mentioned tools and the official python documentation for some of the modules we discussed:

• https://docs.python.org/3/tutorial/inputoutput.html
• https://docs.python.org/3/library/threading.html
• https://wiki.python.org/moin/GlobalInterpreterLock
• https://docs.python.org/3/library/concurrent.futures.html

Readers interested in web server programming with technologies such aiohttp and asyncio should look to frameworks such as Flask (http://flask.pocoo.org) and Django (https://www.djangoproject.com).