You are currently viewing Python: Combining Basic Concepts
python fundamentals

Python: Combining Basic Concepts

python Logo White

A Beginner's Guide to Variables, Loops, and Math Operators in Python

In the world of programming, understanding variables, loops, and mathematical operators is fundamental. They form the building blocks for creating powerful and dynamic applications. In this post, we’ll embark on a journey to explore these concepts through the creation of a simple yet enlightening project – the “Multiplication Bot.” This Python program will continuously calculate multiplication tables, incrementing the numbers indefinitely as it runs.

Why the Multiplication Bot?

The “Multiplication Bot” serves as an excellent example for beginners because it integrates several core programming concepts including:

  • Variables: Variables are like containers that hold data. In our case, we’ll use them to store values for the factors (a and b) and the result (c) of the multiplication operation. We’ll increment these variables in a controlled manner using loops.

  • Loops: Loops are essential for automating repetitive tasks. We’ll use nested for loops to control the flow of the multiplication tables generation. This helps us understand how to iterate through data efficiently.

  • Math Operators: Math operators like * for multiplication will be used to perform the actual calculations. This post will explain how these operators work and how they are applied in the context of our “Multiplication Bot.”

The Code

from time import sleep  # Import the sleep function to handle time delays
dt = .000000000000000000000001  # Set a tiny delay (superFly)
b = 1  # Starting point for our times tables

def timesTables():  # Define a function
    global b  # Allow access to the 'b' variable outside the function
    a = 1  # Starting point for our times tables
    for i in range(1, 15):  # Loop from 1 to 14
        c = a * b  # Perform the multiplication
        # Concatenate strings to create the output
        print(str(b) + " x " + str(a) + " = " + str(c))
        a += 1  # Increment 'a' for the next iteration
        sleep(dt)  # Introduce a tiny time delay

    b += 1  # Increment 'b' to loop over again

while True:  # An infinite loop
    timesTables()  # Call the timesTables function
Breaking Down the Code

  • Importing the sleep Function: We start by importing the sleep function from the time module, which allows us to introduce time delays.

  • Setting Variables: We initialize the dt (delay time) and b variables, where b will be our starting point for generating times tables.

  • Defining a Function: We create a function named timesTables(). Functions are reusable blocks of code that do nothing until they are called.

  • Using global: We use the global keyword to access the variable b declared outside the function within the function itself.

  • For Loop: Inside the timesTables() function, there’s a for loop that runs from 1 to 14. The loop generates multiplication tables.

  • Multiplication: The code calculates the result c by multiplying a and b.

  • String Concatenation: The print statement combines strings to display the multiplication equation and its result.

  • Incrementing ‘a’: We increment the a variable to move to the next number in the multiplication table.

  • Introducing a Delay: A tiny time delay is introduced using the sleep function. It’s important for visualizing the times tables.

  • Incrementing ‘b’: After generating one set of multiplication tables, we increment b to start the process again with a different factor.

  • Infinite Loop: The code enters an infinite loop using while True.

  • Function Invocation: Inside the infinite loop, we repeatedly call the timesTables() function to generate times tables endlessly.

The Result

As you can see from the image below it shows the program runs indefinitely until you stop it, what you can’t see is this process with the delay time we have set runs very fast. It would in fact run even faster if we removed the delay altogether but the point of adding the delay time was so you could alter the dt = variable to slow it down dt = 1 would make calculations every second instead.

This script was originally created for my Python Crash Course to help beginners understand some basic concepts.

Python program

Conclusion

This code serves as a fantastic example of how functions, loops, and string concatenation work together in Python to create dynamic and educational programs. It’s a valuable resource for beginners looking to understand these core concepts and how they can be applied in practical coding scenarios.

Find more of our Python guides here: Python Guides

Recommendation:

Big Book of Small Python Programs: 81 Easy Practice Programs: https://amzn.to/3rGZjCR

Tags: ,

Luke Barber

Hey there! I’m Luke, a tech enthusiast simplifying Arduino, Python, Linux, and Ethical Hacking for beginners. With creds like CompTIA A+, Sec+, and CEH, I’m here to share my coding and tinkering adventures. Join me on Meganano for easy guides and a fun dive into tech, no genius required!