Python Tutorial 20: Understanding Python Threads and Threading

Name: Python Tutorial 20: Understanding Python Threads and Threading
Uploaded: 2021-07-07T16:30:12.000Z
Duration: 1 h 56 s

Introduction to Threading in Python

Overview of the Tutorial

Paul McQuarter introduces episode 20 of his tutorial series on Python, emphasizing the importance of learning threading.

He encourages viewers to prepare with coffee and acknowledges supporters on Patreon for their contributions to the channel.

Importance of Threading

The lesson focuses on threading, a crucial concept for future lessons, building upon previous knowledge about classes and methods.

Paul explains that traditional programming executes one line at a time, which can be limiting when working with multiple tasks or sensors.

Understanding the Need for Threading

Problem with Sequential Execution

He highlights the issue of executing code sequentially, which is problematic when needing to perform multiple actions simultaneously (e.g., interacting with sensors).

To illustrate this need, he plans to demonstrate a simple problem that will show how threading can solve execution limitations.

Setting Up the Example Program

Creating a New Python File

Paul transitions to Visual Studio Code to create a new Python file named red_example.py, setting up for coding.

Conceptualizing the Box Example

He describes an example involving a box that opens and closes while controlling an LED inside it. The goal is to manage timing effectively during these operations.

Implementing Basic Functionality

Importing Necessary Libraries

Paul imports the time library using from time import * to facilitate delays in his program.

Writing Initial Code Logic

He writes code that prints messages indicating when the box is open or closed and includes sleep commands for timing between actions.

Creating an Infinite Loop

Continuous Operation of Box Actions

To keep opening and closing the box indefinitely, he implements a while loop (while True:), ensuring continuous operation without user intervention.

Final Adjustments and Testing

Paul emphasizes that in real applications, commands would be sent to hardware (like servos), but here he simplifies it by just printing messages.

Understanding Threading in Programming

Introduction to the Problem

The speaker discusses a programming scenario involving opening and closing a box while simultaneously blinking an LED.

The intention is to have the LED on for one second and off for another, but the current approach leads to delays that lock up the code execution.

Challenges with Sequential Execution

The speaker highlights that using sleep commands causes the program to pause, preventing simultaneous actions like turning on the LED.

This sequential execution model means that once a line of code is executed, it must complete before moving to the next, leading to inefficiencies.

Introducing Threading as a Solution

To address these issues, threading is introduced. Threads allow multiple operations to run independently without blocking each other.

By launching separate threads for different tasks (like opening/closing the box and controlling the LED), both can operate concurrently.

Setting Up Functions for Threading

The speaker emphasizes creating functions for each task: one for managing the box and another for controlling the LED.

Importing necessary libraries (time and threading) is essential; specifically noting case sensitivity in naming conventions.

Defining Box and LED Functions

A function named my_box is defined which prints messages about opening and closing the box with appropriate sleep intervals.

Another function called my_led manages turning on and off an LED with its own timing logic.

Implementing Infinite Loops

Both functions are placed within infinite loops (while true) so they can continuously execute their respective tasks.

However, this creates a problem where calling one function locks out others from executing due to being stuck in an infinite loop.

Creating Threads for Concurrent Execution

To resolve this issue, threads need to be set up. The speaker explains how to create threads targeting specific functions without starting them immediately.

A thread named box_thread is created targeting my_box, illustrating how threads can be initiated while maintaining clarity in naming conventions related to their purpose.

Threading in Python: Managing Multiple Threads

Setting Up Threads

The speaker introduces the concept of creating threads in Python, specifically for functions my_box and my_led, which are assigned to box_thread and led_thread.

A warning is given about potential issues with orphaned threads if the main program is terminated without properly managing them.

To prevent orphaned threads, the speaker suggests setting both box_thread.daemon and led_thread.daemon to true, ensuring they terminate when the main program ends.

Starting Threads

The process of starting both threads is outlined using .start() method calls on each thread object.

An explanation follows regarding how an infinite loop will run in a separate thread while the main program may end immediately after starting these threads.

Maintaining Program Execution

To keep the main program running while allowing other threads to execute, a perpetual loop (while True) is introduced that does nothing but pass control.

The speaker emphasizes clarity by visually organizing code output to differentiate between states of "my box" being open or closed.

Observing Thread Behavior

Upon execution, results show alternating LED states corresponding with box status changes, demonstrating successful threading functionality.

Further adjustments are made for better visual clarity in output messages indicating box status.

Adding Functionality with Counters

A counter variable (j) is introduced within the infinite loop to demonstrate that it can operate alongside other threaded functions without interference.

The implementation shows that multiple operations can occur simultaneously within different threads without disrupting one another's processes.

Passing Parameters to Threads

Discussion shifts towards passing parameters into threaded functions. The need for flexibility in parameterization (e.g., delay times for each function call) is highlighted.

The speaker explains how to define parameters like delay_t and demonstrates how they can be passed during thread initialization.

This structured approach provides a comprehensive overview of threading concepts discussed in the transcript while maintaining clear links to specific moments for further exploration.

Understanding Thread Arguments in Python

Passing Arguments to Threads

The speaker discusses the necessity of including a comma when passing a single argument to a thread, highlighting this as an unusual requirement in Python.

The process of setting up arguments for threads is explained, with specific mention of using delay box and delay led as examples.

A demonstration shows that omitting the trailing comma when passing one argument causes the thread to crash, confirming its importance.

When passing two arguments (e.g., "red" and "blue"), no trailing comma is needed, illustrating how argument handling differs based on quantity.

The speaker expresses confusion over why Python requires a trailing comma for single arguments but not for multiple ones.

Practical Application of Threads

In practical applications, threads can be used to read data from sensors like GPS and pressure sensors simultaneously.

To pass data from threads back to the main program, creating a class is recommended; this allows easy access to parameters set within the thread.

The speaker encourages revisiting previous lessons on classes for better understanding of integrating threading with object-oriented programming.

Summary of Learning Outcomes

A recap highlights key concepts learned throughout the lessons: mathematical operators, control structures (if statements, loops), file handling (pickling), functions, methods, classes, and threading.

The speaker emphasizes that learners now possess a robust toolkit in Python capable of tackling various programming challenges independently.

What’s Next After Basic Python?

Introduction to Visual Python

Upcoming lessons will focus on Visual Python (VPython), which enables impressive 3D graphics and simulations using what has been learned so far.

An example scenario involves visualizing real-time temperature data through graphical representations like thermometers in 3D space.

Future Learning Directions

Following Visual Python lessons, there will be instruction on connecting Python with external devices such as Arduino or Raspberry Pi for real-world data integration.

Additional topics will include graphing techniques and advanced data analysis within Python.

Engaging with Our Content

Encouragement to Interact

Viewers are encouraged to engage with the channel by giving a thumbs up, subscribing, and activating notifications for new lessons.

The importance of sharing content on social media is emphasized, highlighting the need for more coders and engineers in the world.

A humorous contrast is made between productive coding/engineering activities and watching "silly cat videos," suggesting a call to action for viewers to focus on skill development.