Basics of Python Programming, Part 2

Welcome to Part 2 of my series on Python programming basics! In the previous article, I covered a range of fundamental topics such as variables, data types, string formatting, and more. If you haven’t already read Part 1, I highly recommend checking it out for a solid start to Python programming basics.

Now, in this next installment, we’ll be discussing functions, logical operators, conditional statements, Boolean values, and loops.

Functions

Functions are an integral part of programming that allow you to organize your code into reusable blocks. They serve the purpose of encapsulating a set of instructions that perform a specific task. You can then use and reuse those encapsulated functions as many times as you want, simply by calling its name.

With functions, you can break down complex problems into smaller, manageable parts, making your code more modular and easier to understand.

def add_numbers(a, b):
    result = a + b
    return result

# Calling the function
sum = add_numbers(5, 3)
print(sum)  # Output: 8

In Python, defining a function follows a straightforward syntax. It starts with the def keyword, followed by the function name and a pair of parentheses.

Any required input parameters are specified within these parentheses. Afterward, a colon is used to indicate the start of the function’s body, which consists of one or more indented lines of code.

As I mentioned at the start, one of the key advantages of using functions is code reusability. Once you define a function, you can call it multiple times throughout your program, eliminating the need to duplicate code. This saves time and effort while promoting cleaner and more maintainable code.

Additionally, if you need to make a change or fix a bug within a function, you only need to modify it in one place, resulting in easier code maintenance.

In the example above, we defined a function called add_numbers that took two parameters a and b. The function adds these two numbers together and returns the result. We can call this function as many times as we want throughout the life of our program.

Conditional Statements

Conditional statements play a crucial role in programming by enabling us to make decisions and execute specific blocks of code based on different conditions.

In Python, conditional statements are implemented using the if, elif, and else keywords. The general syntax for an if statement is as follows:

if condition:
    # Code block to execute if the condition is true

The condition is an expression that evaluates to either True or False. If the condition is true, the code block beneath it is executed; otherwise, it is skipped.

We can extend the if statement by including the elif (short for “else if”) clause, which allows us to check additional conditions. The syntax for elif is as follows:

if condition1:
    # Code block to execute if condition1 is true
elif condition2:
    # Code block to execute if condition2 is true

Here, condition1 and condition2 are separate expressions that are evaluated in order. If condition1 is true, its corresponding code block is executed, and the rest of the elif statements are skipped.

If condition1 is false, the program checks condition2, and if it is true, the code block beneath the elif statement is executed. This process continues for multiple elif clauses.

Lastly, we can include the else clause, which acts as a catch-all option for cases where none of the preceding conditions are true. The syntax for else is as follows:

if condition1:
    # Code block to execute if condition1 is true
elif condition2:
    # Code block to execute if condition2 is true
else:
    # Code block to execute if none of the above conditions are true

The else clause does not have a condition associated with it. If none of the previous conditions are true, the code within the else statement is executed.

Conditional statements help control the flow of execution in our programs, allowing them to adapt based on different situations. Thanks to these statements, we can direct the program to perform specific actions or execute particular code blocks based on the outcome of conditional evaluations.

weather = "rainy"

if weather == "sunny":
    print("Remember to wear sunscreen!")
elif weather == "rainy":
    print("Don't forget your umbrella!")
elif weather == "cloudy":
    print("Bring a light jacket, just in case.")
else:
    print("Check the weather forecast for today.")

# Output: Don't forget your umbrella!

In our example program above, our code checks the value of the variable weather and executes the corresponding code block based on its value.

Since weather is “rainy,” the code block under the elif weather == "rainy" statement is executed, resulting in the message “Don’t forget your umbrella!” being printed. The rest of the elif statements underneath it are not executed because the program already found a match.

Logical Operators

Logical operators are essential tools in programming that allow us to combine and evaluate conditions. They enable us to make more complex decisions based on multiple conditions and control the flow of our programs accordingly. In Python, the three main logical operators are AND, OR, and NOT.

AND Operator

condition1 and condition2

The AND operator returns True only if both conditions on either side of it are true. If any of the conditions are false, the result is False.

OR Operator

condition1 or condition2

The OR operator returns True if at least one of the conditions on either side of it is true. It only evaluates the second condition if the first one is false.

NOT Operator

not condition

The NOT operator is used to negate the value of a condition. It returns the opposite Boolean value of the condition. If the condition is True, NOT will return False, and vice versa.

Logical operators can be used to create more complex conditions by combining multiple expressions. For example:

age = 25
marks = 85

if age >= 18 and marks >= 80:
    print("You are eligible.")

In this example, the condition age >= 18 and marks >= 80 uses the AND operator to check if both age is greater than or equal to 18 and marks are greater than or equal to 80. Only when both conditions are true, the eligibility message is printed.

Short-circuit Evaluation

One important behavior of logical operators is short-circuit evaluation. It means that the evaluation of the second condition is skipped if the first condition is sufficient to determine the overall result.

For example:

x = 5
y = 0

if y != 0 and x / y > 2:
    print("Result:", x / y)

In this example, the condition y != 0 and x / y > 2 involves the AND operator. However, since the first condition y != 0 is false (y is indeed 0 in this case), Python does not evaluate the second condition x / y > 2 because the overall result would always be false regardless of the second condition.

This prevents potential errors or exceptions that could arise from evaluating the second condition with an invalid value of y.

Booleans

In Python, the Boolean data type represents truth values. There are two Boolean values: True and False. Booleans are fundamental in decision-making, allowing us to evaluate conditions and determine the flow of our programs based on their truthiness.

Logical operators, as discussed earlier, are closely tied to Booleans. The truth table shows the result of applying logical operators to Boolean values. Here is a truth table for the AND, OR, and NOT operators:

The Truth Table of Booleans

AND Operator

True and True  => True
True and False => False
False and True  => False
False and False => False

OR Operator

True or True  => True
True or False => True
False or True  => True
False or False => False

NOT Operator

not True => False
not False => True

Booleans play a significant role in conditional statements and logical evaluations. We can use boolean values directly in conditional statements or evaluate expressions that result in boolean values.

Here’s an example:

age = 25

if age >= 18:
    print("You are an adult.")
else:
    print("You are not an adult.")

Determining whether a variable is higher than a given number can be achieved through the use of logical operators and can produce different results.

Truthy vs Falsy Values

Python has a concept of truthiness and falsiness, which determines the boolean value of an expression or value by default. Simply put, every value in Python has an inherent truthiness or falsiness value to it. Generally, the following values are considered falsy:

False
None
Zero of any numeric type (0, 0.0, 0j)
Empty sequences (strings, lists, tuples)
Empty mappings (dictionaries)
Empty sets

All other values are considered truthy. Understanding truthiness and falsiness helps us evaluate conditions and make decisions based on the given values.

Loops

Loops are what allow us to execute a block of code repeatedly over and over again. They are particularly useful when we need to perform repetitive tasks or iterate over a collection of items. In Python, we have two main types of loops: for loops and while loops.

For Loops

For loops are commonly used when we want to iterate over a sequence of elements, such as a list, string, or range of numbers. The basic syntax of a for loop in Python is as follows:

for item in sequence:
    # Code block to be executed

The loop iterates over each item in the sequence, assigning the current item to the variable item, and executes the code block associated with the loop. This process continues until all items in the sequence have been processed.

For example, let’s iterate over a list of numbers and print each item:

numbers = [1, 2, 3, 4, 5]

for num in numbers:
    print(num)

This will output:

While Loops

While loops are useful when we want to repeat a block of code as long as a certain condition is true (and we don’t know how many times we need to loop). The basic syntax of a while loop in Python is as follows:

while condition:
    # Code block to be executed

The loop repeatedly executes the code block as long as the condition remains true. It’s important to ensure that the condition eventually becomes false; otherwise, the loop will continue indefinitely, resulting in an infinite loop. An infinite loop never stops and can eventually freeze the program.

Here’s an example of a while loop that prints numbers from 1 to 5:

count = 1

while count <= 5:
    print(count)
    count += 1

This will output:

For Loop vs While Loop

For loops are suitable when we have a known number of iterations, as they automatically handle iterating over the elements of a sequence. On the other hand, while loops are more flexible and allow us to repeat a block of code until a specific condition is met, regardless of the number of iterations.

When deciding between a for loop and a while loop, consider the nature of the task and whether you have a fixed sequence to iterate over or a condition to evaluate.

Loops are powerful constructs that simplify repetitive tasks and help us process data efficiently. By leveraging for and while loops, we can automate repetitive operations, iterate over collections, and solve a wide range of problems that involve repetition or conditional execution.

Conclusion

I’ve covered various fundamental concepts and constructs that form the building blocks of any Python code in two articles so far. In Part 1, we explored variables, identifiers, arithmetic expressions, data types, and string formatting, among other topics. Now, in Part 2, we have delved into more essential concepts, including functions, conditional statements, logical operators, and loops.

Functions enable you to encapsulate reusable blocks of code, promoting code modularity and enhancing the readability of your programs. Conditional statements allow you to make decisions and control the flow of execution based on different conditions.

Logical operators provide a means to combine and evaluate conditions, giving you the ability to express complex logic and perform logical operations. Understanding booleans and truthiness helps you work with logical values and make informed decisions based on whether something is True or False.

Finally, loops equip you with the ability to automate repetitive tasks and iterate over sequences or execute code as long as certain conditions are met. By harnessing the power of loops, you can process large amounts of data, manipulate collections, and perform iterative computations efficiently.

Last Updated on October 4, 2024