Random Expert

Subscribe

Random Expert

Mastering Python: Your Journey from Basics to Beyond

Random Expert 69 mins0
Mastering Python: Your Journey from Basics to Beyond

Mastering Python: Your Journey from Basics to Beyond

Welcome, aspiring developers! Are you ready to dive into the world of Python, the programming language that’s powering everything from artificial intelligence to web development? This comprehensive course article is designed to take you from the absolute fundamentals of Python to understanding its core concepts, setting you up for a confident start in your coding journey.

In this article, we’ll explore Python’s versatility, set up your development environment, and then progressively delve into essential programming constructs. We’ll touch upon how Python handles data, how to make decisions in your code, and how to automate repetitive tasks.

Learning Objectives:

  • Understand why Python is a popular and powerful programming language.
  • Set up your Python development environment using VS Code.
  • Write and execute basic Python scripts.
  • Comprehend fundamental data types: strings, numbers (integers, floats, complex), and booleans.
  • Utilize string manipulation techniques and built-in functions.
  • Perform arithmetic operations and understand augmented assignment operators.
  • Apply comparison and logical operators to build complex conditions.
  • Implement conditional statements (if, elif, else) for decision-making.
  • Construct for and while loops for code repetition.
  • Define and use custom functions with parameters and arguments.
  • Distinguish between different types of Python functions (task-performing vs. value-returning).
  • Grasp the concept of iterable objects and how to loop over them.

Prerequisites:

This course is crafted with beginners in mind. You don’t need any prior programming knowledge to get started. I’ll explain everything step by step, in simple terms, so you can build a solid foundation.

Why Python? A Look at the World’s Fastest-Growing Language

Python isn’t just a programming language; it’s a phenomenon. It’s the world’s fastest-growing and most popular choice, not just among software developers, but also among mathematicians, data analysts, scientists, accountants, network engineers, and even, well, kids! It’s often considered the ideal first language to learn, and I think you’ll soon see why.

So, what makes Python so special?

  1. Efficiency: You can solve complex problems in less time, with fewer lines of code, compared to many other languages. This is why tech giants like Google, Spotify, Dropbox, and Facebook have wholeheartedly embraced this elegant and powerful tool.
  2. Versatility: Python is a multi-purpose language. You can use it for a vast array of tasks:
    • Data Analysis
    • AI and Machine Learning
    • Writing Automation Scripts
    • Building Web, Mobile, and Desktop Applications
    • Software Testing
    • Even, dare I say, hacking!

    If you’re eyeing a high-paying, long-lasting career in any of these areas, especially AI and machine learning, Python can certainly put those opportunities right at your fingertips.

  3. High-Level Language: Python handles complex tasks like memory management for you, unlike languages such as C++. This means you can focus more on solving the problem at hand rather than getting bogged down in low-level details.
  4. Cross-Platform Compatibility: Python applications can be built and run seamlessly on Windows, macOS, and Linux. Write once, run anywhere, as they say!
  5. Vibrant Community: Whenever you get stuck (and trust me, we all do!), there’s a massive, supportive community ready to help. You’re never truly alone on your Python journey.
  6. Rich Ecosystem: Python boasts a huge ecosystem of libraries, frameworks, and tools. Whatever you want to do, chances are someone else has already done it, and there’s a well-tested library for it. Python has been around for over 20 years, so it has a mature and extensive collection of resources.

Python 2 vs. Python 3: A Quick Note

You might encounter references to Python 2, which is the legacy version. However, for this course, and for any new development, we will be focusing exclusively on Python 3, which is the future of Python.

Setting Up Your Python Development Environment

Before we write our first line of code, we need to set up our development environment. This involves installing Python and choosing a code editor.

1. Installing Python

First things first, let’s get Python installed on your machine.

  • Open your web browser and navigate to python.org.
  • Look for the “Downloads” section. At the time of this writing, the latest version is Python 3.13. Don’t worry if a newer version is available when you’re reading this; the concepts we cover will still apply.
  • Download the latest version appropriate for your operating system.

Important for Windows Users:

During the installation process, make sure to check the box that says “Add Python to PATH.” This step is absolutely crucial and will save you a lot of headaches later on. Once checked, proceed with the installation.

2. Verifying Your Python Installation

Let’s make sure Python is installed correctly.

  • On Windows:
    • Click the magnifier icon (search bar) in your taskbar.
    • Type terminal and open the Terminal application.
    • In the terminal window, type python --version and press Enter. You should see Python 3.13 (or whatever version you installed).
  • On Mac:
    • Press Command + Space to bring up Spotlight Search.
    • Type terminal and open the Terminal application.
    • In the terminal window, type python3 --version and press Enter. You should see Python 3.13 (or your installed version).

If you see the version number, congratulations! Python is successfully installed.

3. Understanding the Python Interpreter

The environment you just interacted with in your terminal is called the Python Interpreter. It’s essentially a program that executes Python code. We can either type Python code directly into this interactive shell for quick experiments, or, more commonly, we write our code in a file and then give that file to the interpreter to execute.

Let’s try a quick experiment in the interactive shell:

2 + 2

When you press Enter, you’ll see 4. This is an expression – a piece of code that produces a value.

Try another one:

2 > 1

This will return True, which is an example of a Boolean value.

What if we type something incomplete?

2 >

You’ll get a SyntaxError. In programming, syntax means grammar. Just like spoken languages have grammar rules, so do programming languages. If your code isn’t grammatically correct, the interpreter won’t understand it.

While the interactive shell is great for quick tests, for building real-world applications, we need a proper code editor.

4. Choosing Your Code Editor: VS Code

When it comes to writing Python code, you have two main options: a code editor or an IDE (Integrated Development Environment).

  • Code Editor: A basic text editor with features like syntax highlighting. Popular choices include VS Code, Atom, and Sublime Text.
  • IDE: A code editor with fancy features like:
    • Autocompletion: Helps you write code faster by suggesting completions.
    • Debugging: Tools for finding and fixing errors (bugs) in your programs.
    • Testing: Features for writing and running automated tests.
    • Code Formatting: Tools to make your code clean and readable.

    The most popular IDE for Python is PyCharm.

For this course, I’ll be using VS Code (Visual Studio Code). It’s my favorite code editor, and later, we’ll install an extension that transforms it into a powerful IDE.

5. Installing VS Code

  • Head over to code.visualstudio.com and download the latest version of VS Code for your operating system.
  • Follow the installation instructions.

Your First Python Program: “Hello, World!”

Now that we have our tools ready, let’s write our very first Python program. It’s a tradition in programming to start with “Hello, World!”

1. Creating Your Project Folder

  • Open VS Code.
  • From the File menu, select Open Folder... (or Open... on Mac).
  • Somewhere on your disk, create a new folder. Let’s call it hello_world.
  • Open this newly created folder in VS Code.

2. Creating Your Python File

  • In VS Code, click the Explorer icon on the left sidebar (it looks like two overlapping papers). This panel shows all files and folders in your project.
  • Click the New File icon (a blank page with a plus sign) and name your file app.py. All Python files should have the .py extension.

3. Writing the Code

Now, in your app.py file, type the following:

# This is our first Python program!
# We're using the built-in 'print' function.
print("Hello, World! 👋")

Let’s break this down:

  • # This is our first Python program!: This is a comment. Comments are notes you add to your code to explain what it does. The Python interpreter ignores anything after a # sign.
  • print(): This is a built-in function in Python. Think of functions like buttons on a TV remote control (e.g., “turn on,” “change channel”). They perform specific tasks. The print() function, as its name suggests, displays whatever you put inside its parentheses on the screen (or in our case, the terminal).
  • "Hello, World! 👋": This is a string (text). Whenever you work with text in Python, you need to enclose it in quotes, either double quotes (") or single quotes (').

4. Running Your Program

To execute this code, we’ll use VS Code’s integrated terminal.

  • Press Ctrl + ` (backtick, the key usually below Esc) to open the integrated terminal.
  • On Windows: Type python app.py and press Enter.
  • On Mac/Linux: Type python3 app.py and press Enter.

You should see:

Hello, World! 👋

Beautiful! You’ve just run your first Python program.

5. Taking it a Step Further: String Multiplication

Let’s make things a bit more interesting. Close the terminal (by pressing Ctrl + ` again) and add a second line of code to app.py:

print("Hello, World! 👋")
print("*" * 10) # This multiplies the string by 10

Save the changes (Ctrl + S or Cmd + S). Now, run the program again in the integrated terminal:

Hello, World! 👋
**********

You can see the asterisk (*) is repeated 10 times! This demonstrates that instructions in Python programs are executed from top to bottom, in order.

Supercharging VS Code: The Python Extension

To truly make VS Code a powerful IDE for Python development, we need to install the official Python extension. This extension provides a wealth of features that will boost your productivity.

1. Installing the Python Extension

  • In VS Code, click the Extensions icon on the left sidebar (it looks like four squares, one flying away).
  • In the search bar at the top, type python.
  • Look for the official “Python” extension from Microsoft. Go ahead and click Install.
  • You might see a “Reload” button after installation. If so, click it to reload VS Code.

2. New Features with the Extension

With this extension installed, VS Code gains a ton of new functionality for writing Python code.

  • Run Button: Notice the new “Play” icon at the top right of your app.py file. You can now simply click this to run your code, and the output will appear in the terminal window.
  • Linting: This feature analyzes your code for potential errors as you type, providing real-time feedback.
  • Debugging: Tools for finding and fixing bugs.
  • Autocompletion: Helps you write code faster by suggesting completions.
  • Code Formatting: Automatically formats your code to make it clean and readable.
  • Unit Testing: For writing automated tests for your code.
  • Code Snippets: Reusable blocks of code that you can quickly generate.

Don’t worry about memorizing all these right now; we’ll encounter many of them throughout this course.

3. Linting in Action: Catching Errors Early

Let’s see linting in action. In your app.py file, intentionally write some invalid Python 3 code:

print Hello World

As soon as you save the changes, you’ll likely see a red wavy underline beneath print. If you hover your mouse over it, a tooltip will appear, often from “Pylint” (a popular Python linter), giving you an error message like: “Missing parentheses in call to ‘print’. Did you mean print(‘Hello World’)?”

This is the beauty of linting! It catches potential problems as you’re writing, so you don’t have to wait until you run your program to discover errors.

Now, fix the error:

print("Hello World")

The red underline should disappear.

Let’s try another error:

2 +

Hovering over this will show an “invalid syntax” error, just like in the interactive shell. It’s like an incomplete sentence.

4. The Problems Panel and Command Palette

  • Problems Panel: Go to View > Problems (or use the shortcut Shift + Command + M on Mac, Shift + Control + M on Windows). This panel lists all the issues in your code, across multiple files, in one place. It’s incredibly useful for larger projects.
  • Command Palette: Go to View > Command Palette... (or Shift + Command + P on Mac, Shift + Control + P on Windows). This is a powerful feature that lets you execute various commands in VS Code. If you type lint here, you’ll see commands related to linting, many prefixed with “Python” because they come from the Python extension. You can even select different linters (like Flake8, MyPy, PEP 8) if you’re feeling adventurous, though Pylint is the default and most popular.

Formatting Your Code: Embracing PEP 8

In the Python community, we have a set of documents called Python Enhancement Proposals (PEPs). These are guidelines for writing Python code. One of the most popular is PEP 8, which is a style guide for Python code.

A style guide defines rules for formatting and styling your code. By following these conventions, your code will be consistent with other people’s code, making it easier to read and maintain. While you can read the full PEP 8 documentation, I’ll highlight the key aspects throughout this course.

Automatic Code Formatting with AutoPEP8

Let’s see how automatic formatting works. Add the following line to your app.py file (don’t worry about what variables are for now; we’ll cover them soon):

x=1

According to PEP 8, this is considered “ugly” because we should add spaces around the assignment operator (=).

Now, let’s use a tool to automatically format this:

  • Open the Command Palette (Shift + Command + P or Shift + Control + P).
  • Search for format document and select it.

The first time you do this, you might see a message like “Formatter autopep8 is not installed.” AutoPEP8 is a popular tool for formatting Python code according to PEP 8.

  • If prompted, click Install to install AutoPEP8. Alternatively, you can go to the Extensions panel, search for autopep8, and install it manually.
  • Once installed, open the Command Palette again and execute Format Document.

You’ll see your code automatically formatted to:

x = 1

Beautiful!

Let’s try another example:

x = 1
y=2
unit_price=3

Some developers might try to align the equal signs, like this:

x          = 1
y          = 2
unit_price = 3

According to PEP 8, this is also considered ugly. Run Format Document again, and AutoPEP8 will fix it for you.

Format on Save: A Time-Saving Trick

Opening the Command Palette and searching for format document every time can be a bit tedious. Let’s configure VS Code to automatically format your file as soon as you save changes.

  • Go to Code (or File on Windows) > Preferences > Settings.
  • In the search box, type format on save.
  • Check the option Editor: Format On Save.

Now, go back to app.py, intentionally make some lines “ugly” again, and then save the file. You’ll see your code instantly reformatted!

While these tools are fantastic, it’s a good habit to try and write clean code from the start, without relying too heavily on automated formatting.

Understanding Python Implementations

When we talk about “Python,” we’re actually referring to two closely related things:

  1. Python Language: This is the specification that defines the rules and grammar for writing Python code.
  2. Python Implementation: This is a program that understands those rules and can execute Python code.

The Python you downloaded from python.org is the default implementation called CPython. It’s written in C, hence the name.

There are other implementations out there:

  • Jython: Written in Java.
  • IronPython: Written in C#.
  • PyPy: Written in a subset of Python itself.

As new features are added to the Python language, they are usually first supported by CPython, and then gradually by other implementations. In theory, if you give the same Python code to any of these implementations, you should get the same result. In practice, however, certain features might behave slightly differently or not be available in all implementations.

Why Multiple Implementations?

You might wonder, “Why do we need several implementations? Wouldn’t CPython be enough?” It’s a bit like having multiple operating systems or web browsers – programmers haven’t agreed on a single perfect solution!

However, there’s a key technical reason:

  • Jython allows you to reuse existing Java code in a Python program. If you’re a Java developer, you can import Java code into your Python projects.
  • Similarly, IronPython lets you integrate C# code into Python.

How CPython Executes Code

Let’s briefly touch upon how CPython executes your Python code.

Programming languages like C, Java, and Python are human-readable, text-based languages. Computers, though, only understand machine code.

  1. C Compiler: For C code, a C compiler converts it directly into machine code. However, this machine code is specific to the CPU type. A C program compiled on Windows won’t run on a Mac because they have different machine codes.
  2. Java’s Solution: Java introduced a solution to this platform dependency. A Java compiler compiles Java code into Java bytecode, which is a portable language not specific to any hardware platform. Then, a Java Virtual Machine (JVM) converts this bytecode into machine code at runtime, allowing Java programs to run on any platform with a JVM.
  3. Python’s Approach: Python (and CPython specifically) takes a similar route to achieve platform independence.
    • When you run a Python program using CPython, it first compiles your Python code into Python bytecode.
    • Then, it passes that bytecode to the Python Virtual Machine, which in turn converts it into machine code and executes it.

This is how CPython works. If you use Jython, it would compile your Python code into Java bytecode, which is then executed by the JVM, allowing for Java code integration.

Core Concepts: Variables, Data Types, and Operators

Now that our environment is set up and we understand a bit about how Python works under the hood, let’s dive into the core concepts of programming.

1. Variables: Storing Data

In programming, we use variables to store data in a computer’s memory. Think of a variable as a label for a memory location.

students_count = 1000

When you run this, the Python interpreter allocates some memory, stores the number 1000 in it, and then the variable students_count acts as a reference (or label) to that memory location. You can then use this variable anywhere in your program to access that data.

students_count = 1000
print(students_count)

Running this will output 1000.

2. Primitive Data Types

What kind of data can we store? Python has several built-in primitive types:

  • Numbers:
    • Integers (int): Whole numbers (e.g., 1000). 
      age = 30 # An integer
    • Floats (float): Numbers with a decimal point (e.g., 4.99). 
      rating = 4.99 # A float
    • Complex Numbers: Numbers in the form $a + bj$ (where $j$ is the imaginary unit). You’ll likely only encounter these in specialized mathematical or engineering applications. 
      complex_number = 1 + 2j # A complex number
  • Booleans (bool): Represent truth values – either True or False. These are like “yes” or “no” in English and are crucial for making decisions in your programs. 
    is_published = True # A boolean

    Important: Python is a case-sensitive language. Boolean values True and False must always start with a capital letter. true or false (lowercase) are not valid Boolean values in Python.

  • Strings (str): Text data. Always enclose strings in quotes. 
    course_name = "Python Programming" # A string

    You can use either double quotes (") or single quotes ('). Often, double quotes are preferred.

    For long strings that span multiple lines, or to include special formatting, you can use triple quotes (""" or '''):

    message = """
Hi John,
This is me from the course.
Hope you're enjoying Python!
"""
print(message)

3. Best Practices for Naming Variables

When naming your variables, consider these best practices:

  • Descriptive and Meaningful: Your variable names should clearly indicate what they store. Avoid mystical names like cn (for course name) or c1. students_count is much clearer than sc.
  • Lowercase Letters: Use lowercase letters for variable names.
  • Underscores for Multiple Words: If a variable name has multiple words, separate them with underscores (e.g., students_count, course_name). This is known as snake_case and is the convention in Python, as spaces are not allowed in variable names.
  • Spaces around Assignment Operator: Always put spaces around the equal sign (=) when assigning a value (e.g., x = 1 not x=1). This improves readability. While autopep8 will fix this for you, it’s good to develop the habit.

4. Working with Strings in Detail

Strings are fundamental for handling text. Let’s explore some useful operations and methods.

  • Getting the Length of a String (len()):

    The len() function is a built-in Python function that returns the number of characters in a string.

    course = "Python Programming"
print(len(course)) # Output: 18
  • Accessing Characters (Indexing):

    Strings are zero-indexed, meaning the first character is at index 0. You use square brackets ([]) to access individual characters.

    course = "Python Programming"
print(course[0]) # Output: P (the first character)
print(course[‭-1]‬) # Output: g (the first character from the end)
  • Slicing Strings:

    You can extract a portion (a “slice”) of a string using the colon (:) in the square brackets. The syntax is [start_index:end_index]. The character at end_index is not included.

    course = "Python Programming"
print(course[0:3]) # Output: Pyt (characters at index 0, 1, 2)
print(course[0:]) # Output: Python Programming (from start to end)
print(course[:3]) # Output: Pyt (default start is 0)
print(course[:]) # Output: Python Programming (a copy of the original string)
  • Escape Characters:

    What if you want to include a double quote inside a string that’s already defined with double quotes? Python will get confused. You use a backslash (\) as an escape character.

    # Problematic:
# course = "Python "Programming""

# Solution 1: Use single quotes for the outer string
course = 'Python "Programming"'
print(course) # Output: Python "Programming"

# Solution 2: Use escape character with double quotes
course = "Python \"Programming\""
print(course) # Output: Python "Programming"

    \ followed by a character is called an escape sequence. Other common escape sequences include:

    • \': Single quote
    • \\: Backslash
    • \n: New line
    print("Python \\ Programming") # Output: Python \ Programming
print("Python\nProgramming") # Output: Python
                             # Programming
  • Formatted Strings (f-strings):

    Building strings using concatenation (+) can become cumbersome. Formatted strings (f-strings) provide a cleaner, more readable way to embed variables and expressions directly into strings. Prefix the string with f (or F).

    first = "Mosh"
last = "Hamedani"
full = f"{first} {last}" # Using an f-string
print(full) # Output: Mosh Hamedani

# You can also embed expressions:
print(f"Length of first name: {len(first)}") # Output: Length of first name: 4
  • String Methods:

    Strings in Python are objects, and objects have functions associated with them, which we call methods. You access these methods using the dot notation (.).

    course = "   python programming   "

print(course.upper()) # Output:    PYTHON PROGRAMMING   (converts to uppercase)
print(course.lower()) # Output:    python programming   (converts to lowercase)
print(course.title()) # Output:    Python Programming   (capitalizes first letter of each word)
print(course.strip()) # Output: python programming (removes leading/trailing whitespace)
print(course.lstrip()) # Output: python programming    (removes leading whitespace)
print(course.rstrip()) # Output:    python programming (removes trailing whitespace)

print(course.find("Pro")) # Output: 9 (returns the index of the first occurrence, -1 if not found)
print(course.replace("P", "J")) # Output:    jython Jrogramming   (replaces all occurrences)

print("Pro" in course) # Output: True (checks for existence, returns a boolean)
print("swift" not in course) # Output: True (checks for non-existence, returns a boolean)

    Important: String methods generally return a new string. They do not modify the original string.

5. Working with Numbers and Arithmetic Operators

Python supports standard arithmetic operations for numbers.

  • Basic Operators:
    • +: Addition
    • -: Subtraction
    • *: Multiplication
    • /: Division (returns a float)
    • //: Integer Division (returns an integer, discarding the fractional part)
    • %: Modulus (returns the remainder of a division)
    • **: Exponentiation (e.g., 10 ** 3 is $10^3$)
    print(10 + 3)   # Output: 13
print(10 - 3)   # Output: 7
print(10 * 3)   # Output: 30
print(10 / 3)   # Output: 3.3333333333333335
print(10 // 3)  # Output: 3
print(10 % 3)   # Output: 1
print(10 ** 3)  # Output: 1000
  • Augmented Assignment Operator:

    A shorthand for operations like x = x + 3.

    x = 10
x = x + 3   # Equivalent to:
x += 3      # Augmented assignment operator
print(x)    # Output: 16 (if starting from 10, then 10+3=13, then 13+3=16)

    This works with all arithmetic operators (e.g., -=, *=, /=, etc.).

  • Useful Number Functions:
    • round(): Rounds a number to the nearest integer.
    • abs(): Returns the absolute value of a number.
    print(round(2.9)) # Output: 3
print(abs(-2.9))  # Output: 2.9
  • The math Module:

    For more complex mathematical calculations, Python provides the math module. You need to import it to use its functions.

    import math

print(math.ceil(2.2)) # Output: 3 (returns the smallest integer greater than or equal to x)

    You can find a complete list of functions in the math module by searching “Python 3 math module” on Google. As an exercise, try playing with a few of them!

6. Getting Input from the User (input()):

The input() function allows your program to get input from the user. It always returns a string.

x = input("x: ")
print(x)

When you run this (in the terminal, not the VS Code “Run” button, as the output window is read-only), you’ll see x: and can type a value.

7. Type Conversion:

Since input() always returns a string, you often need to convert it to a number if you want to perform mathematical operations. Python provides built-in functions for type conversion:

  • int(): Converts to an integer.
  • float(): Converts to a float.
  • bool(): Converts to a boolean.
  • str(): Converts to a string (though input() already gives you a string).
x = input("x: ")
# Attempting x + 1 directly would cause a TypeError because you can't add a string and a number.
y = int(x) + 1 # Convert x to an integer first
print(f"x: {x}, y: {y}")

8. Truthy and Falsy Values:

In Python, certain values are considered “falsy” (interpret as False in a boolean context), even if they are not explicitly False. Everything else is “truthy” (interpret as True).

Falsy Values:

  • Empty strings ("")
  • The number zero (0)
  • None (represents the absence of a value)

Examples:

print(bool(0))        # Output: False
print(bool(1))        # Output: True
print(bool(-1))       # Output: True
print(bool(""))       # Output: False
print(bool("False"))  # Output: True (because it's not an empty string)
print(bool(None))     # Output: False

Quiz: Test Your Knowledge!

Let’s see if you’ve been paying attention! Pause and think about the answers before revealing them.

Question 1: What are the built-in primitive types in Python?

Solution

Strings, numbers (integers, floats, complex numbers), and booleans.

Question 2: You have the variable fruit = "Apple". What will be printed when you execute print(fruit[1])?

Solution

P. In Python, strings are zero-indexed, so fruit[1] accesses the second character.

Question 3: What will be printed when you execute print(fruit[1:-1])?

Solution

ppl. This slices the string from index 1 up to (but not including) the last character (index -1).

Question 4: What is the result of the expression 10 % 3?

Solution

1. The modulus operator (%) returns the remainder of a division. 10 divided by 3 is 3 with a remainder of 1.

Question 5: What do you think we will see when we print bool("False")?

Solution

True. While the word “False” itself might seem to imply a boolean false, in Python, any non-empty string is considered “truthy.”

Control Flow: Making Decisions and Repeating Actions

Now we’re moving into how programs “think” and “act.” This involves comparison operators, conditional statements, and loops.

1. Comparison Operators

We use comparison operators to compare values. These operators always return a Boolean value (True or False).

  • >: Greater than
  • >=: Greater than or equal to
  • <: Less than
  • <=: Less than or equal to
  • ==: Equal to (note the double equals sign!)
  • !=: Not equal to
print(10 > 3)    # Output: True
print(10 >= 3)   # Output: True
print(10 < 20)   # Output: True
print(10 <= 10)  # Output: True
print(10 == 10)  # Output: True
print(10 == "10") # Output: False (different types)
print(10 != 5)   # Output: True

You can also use these with strings. Python compares strings character by character based on their ASCII/Unicode values.

print("bag" > "apple") # Output: True (because 'b' comes after 'a')
print("bag" == "Bag")  # Output: False (case-sensitive)

2. Conditional Statements (if/elif/else)

In almost every program, you'll need to make decisions. That's where if statements come in.

temperature = 35

if temperature > 30:
    print("It's warm")
    print("Drink water")
print("Done")

Key Points:

  • if keyword: Starts the conditional block.
  • Condition: A Boolean expression (e.g., temperature > 30). If this evaluates to True, the indented code block below it is executed.
  • Colon (:): Always terminate the if statement line with a colon.
  • Indentation: This is critical in Python. Statements that belong to the if block must be indented (typically 4 spaces, which AutoPEP8 will enforce). When you remove the indentation, you signal the end of the if block.
  • Done message: This will always be printed, regardless of the temperature, because it's not indented under the if block.

Multiple Conditions (elif):

You can have multiple conditions using elif (short for "else if").

temperature = 25

if temperature > 30:
    print("It's warm")
elif temperature > 20: # This condition is checked only if the first 'if' is False
    print("It's nice")
print("Done")

Catch-all (else):

Optionally, you can add an else statement. The code in the else block is executed if none of the preceding if or elif conditions are true.

temperature = 15

if temperature > 30:
    print("It's warm")
elif temperature > 20:
    print("It's nice")
else: # Executed if neither of the above conditions are true
    print("It's cold")
print("Done")

3. Cleaner Code with Ternary Operator

For simple if-else statements where you're just assigning a value to a variable, Python offers a more concise way called the ternary operator.

age = 22

# Traditional if-else:
# if age >= 18:
#     message = "Eligible"
# else:
#     message = "Not eligible"

# Using ternary operator:
message = "Eligible" if age >= 18 else "Not eligible"
print(message)

This reads almost like plain English and can make your code much cleaner.

4. Logical Operators (and, or, not)

To model more complex conditions, we use logical operators:

  • and: Returns True if both conditions are True.
  • or: Returns True if at least one condition is True.
  • not: Inverses the Boolean value of a condition.

Let's consider a loan application scenario:

high_income = True
good_credit = True
student = False

# Eligible if high income AND good credit AND NOT a student
if (high_income and good_credit) and not student:
    print("Eligible for loan")
else:
    print("Not eligible for loan")

Important:

  • You don't need to compare a boolean variable with True (e.g., if high_income == True). Just if high_income: is sufficient and more Pythonic.
  • Use parentheses to group conditions for clarity, especially with mixed and/or operators.

5. Short-Circuiting Logical Operators

Python's logical operators are "short-circuit" operators. This means the evaluation stops as soon as the result can be determined.

  • and operator: If the first condition is False, the entire expression will be False, so Python doesn't bother evaluating the subsequent conditions.
  • or operator: If the first condition is True, the entire expression will be True, so Python stops evaluating.

This can sometimes have performance implications or prevent errors if later parts of the expression might cause an issue.

6. Chaining Comparison Operators

Python allows you to chain comparison operators, making your code incredibly clean and readable, similar to how you'd write mathematical inequalities.

age = 22

# Traditional way:
# if age >= 18 and age < 65:
#     print("Eligible")

# Chained comparison:
if 18 <= age < 65:
    print("Eligible")

The chained version (18 <= age < 65) is equivalent to age >= 18 and age < 65 but is much more elegant.

Quiz: Control Flow Challenge!

Another quick quiz to solidify your understanding. What will be the output of this program?

x = 10
y = "10"

if x == y:
    print("A")
elif "bag" > "apple" and "bag" > "cat":
    print("B")
else:
    print("C")
Solution

The output will be C. Let's break it down:

  1. if x == y:: 10 (integer) is not equal to "10" (string) because they are different types. So, this condition is False.
  2. elif "bag" > "apple" and "bag" > "cat":
    • "bag" > "apple": True (alphabetically, 'bag' comes after 'apple').
    • "bag" > "cat": False (alphabetically, 'bag' does not come after 'cat').
    • True and False: This evaluates to False.
  3. Since both the if and elif conditions are False, the else block is executed, printing C.

Loops: Repeating Actions with for and while

Sometimes, you need to repeat a task multiple times. This is where loops come in handy. Python offers for loops and while loops.

1. for Loops: Iterating Over Collections

for loops are used to iterate over "iterable" objects (like ranges, strings, or lists).

Basic for loop with range():

The range() function generates a sequence of numbers.

# Simulate retrying to send a message 3 times
for number in range(3): # Generates numbers 0, 1, 2
    print("Attempt")

Output:

Attempt
Attempt
Attempt

To make the output more meaningful, we can use the number variable:

for number in range(3):
    print(f"Attempt {number + 1}")

Output:

Attempt 1
Attempt 2
Attempt 3

range() with Start, Stop, and Step:

The range() function can take up to three arguments: range(start, stop, step).

  • start: (Optional) The starting number (inclusive, default is 0).
  • stop: The ending number (exclusive).
  • step: (Optional) The increment between numbers (default is 1).
# Start from 1, go up to (but not including) 4, step by 1
for number in range(1, 4):
    print(f"Attempt {number}")

# Output:
# Attempt 1
# Attempt 2
# Attempt 3

# Start from 1, go up to (but not including) 10, step by 2
for number in range(1, 10, 2):
    print(number)

# Output:
# 1
# 3
# 5
# 7
# 9

Iterating over Strings:

Strings are also iterable!

for char in "Python":
    print(char)

# Output:
# P
# y
# t
# h
# o
# n

2. break and else with for Loops

Sometimes, you need to exit a loop early, or perform an action only if the loop completes without interruption.

  • break statement: Immediately terminates the loop. 
    successful = True # Let's assume the message is sent successfully

for attempt in range(1, 4):
    print(f"Attempt {attempt}")
    if successful:
        print("Successful!")
        break # Exit the loop early

    Output:

    Attempt 1
Successful!
  • else block with for loop: The code in the else block is executed only if the loop completes without encountering a break statement. 
    successful = False # Let's assume sending fails

for attempt in range(1, 4):
    print(f"Attempt {attempt}")
    if successful:
        print("Successful!")
        break
else: # This will execute because the loop finished without a 'break'
    print("Attempted 3 times and failed.")

# Output:
# Attempt 1
# Attempt 2
# Attempt 3
# Attempted 3 times and failed.

3. Nested Loops

You can place one loop inside another, creating nested loops. This is useful for tasks like generating coordinates or working with grids.

for x in range(5): # Outer loop (0 to 4)
    for y in range(3): # Inner loop (0 to 2)
        print(f"({x}, {y})")

Output (partial):

(0, 0)
(0, 1)
(0, 2)
(1, 0)
(1, 1)
(1, 2)
...

How it works: The outer loop executes once, and for each iteration of the outer loop, the entire inner loop completes all its iterations.

4. while Loops: Repeating Based on a Condition

while loops repeat a block of code as long as a given condition remains True.

number = 100
while number > 0:
    print(number)
    number //= 2 # Divide by 2 (integer division)

# Output:
# 100
# 50
# 25
# 12
# 6
# 3
# 1

A common use case for while loops is to continuously get input from the user until a specific command is given.

command = "" # Initialize command to an empty string

while command.lower() != "quit": # Convert input to lowercase for comparison
    command = input("> ")
    print(f"Echo: {command}")

# Output (example interaction in terminal):
# > hello
# Echo: hello
# > 2 + 2
# Echo: 2 + 2
# > QUIT
# Echo: QUIT (loop terminates because command.lower() is "quit")

Important: Notice command.lower() != "quit". This converts the user's input to lowercase before comparison, so "Quit", "QUIT", or "quit" all work.

5. Infinite Loops: A Cautionary Tale

An infinite loop is a loop that runs forever because its condition never becomes False.

# DANGER: This is an infinite loop if not handled!
# while True:
#     command = input("> ")
#     print(f"Echo: {command}")

To exit an infinite loop, you must use a break statement based on some condition.

while True: # This loop will run indefinitely until 'break'
    command = input("> ")
    if command.lower() == "quit":
        break # Exit the loop
    print(f"Echo: {command}")

Be mindful of infinite loops, as they can consume system resources and potentially crash your program if not managed properly.

Exercise: Even Numbers Counter

Task: Write a Python program to display all even numbers between 1 and 10 (inclusive of 1, exclusive of 10). After printing the numbers, print a message indicating how many even numbers were found.

Expected Output:

2
4
6
8
We have 4 even numbers

Hint: Use a for loop with range(1, 10). You'll need the modulus operator (%) to check for even numbers.

Solution 

count = 0
for number in range(1, 10):
    if number % 2 == 0: # Check if the remainder when divided by 2 is 0 (i.e., even)
        print(number)
        count += 1 # Increment the counter for even numbers
print(f"We have {count} even numbers")

Functions: Organizing Your Code

As your programs grow, you'll want to organize your code into smaller, more manageable, and reusable chunks. These chunks are called functions.

1. Defining Your Own Functions

You've already used built-in functions like print() and round(). Now, let's create our own.

def greet(): # 'def' keyword defines a function
    print("Hi there!")
    print("Welcome aboard!")

# Call the function (execute its code)
greet()

Key Points:

  • def keyword: Short for "define," it marks the beginning of a function definition.
  • Function Name: Follows the same naming conventions as variables (lowercase, underscores for multiple words).
  • Parentheses (): Essential after the function name, even if it takes no inputs.
  • Colon (:): Terminates the function definition line.
  • Indentation: All code belonging to the function must be indented.
  • Calling the Function: To execute the code inside a function, you "call" it by its name followed by parentheses (e.g., greet()).
  • PEP 8 Recommendation: Add two blank lines after a function definition to improve readability. AutoPEP8 will often do this for you.

2. Parameters and Arguments: Passing Data to Functions

Functions become much more powerful when they can accept inputs.

  • Parameters: These are the inputs you define for your function in its definition (e.g., first_name, last_name).
  • Arguments: These are the actual values you supply for those parameters when you call the function.
def greet(first_name, last_name): # first_name and last_name are parameters
    print(f"Hi {first_name} {last_name}!")
    print("Welcome aboard!")

# Calling the function with arguments
greet("Mosh", "Hamedani") # "Mosh" and "Hamedani" are arguments
greet("John", "Smith")

By default, all parameters you define are required. If you call greet() without providing both arguments, Python will raise an error.

3. Types of Functions: Performing Tasks vs. Returning Values

Functions generally fall into two categories:

  1. Functions that Perform a Task: They do something, like printing to the console, but don't explicitly give back a value. Our greet() function is an example of this.
  2. Functions that Calculate and Return a Value: They compute something and give the result back to the caller using the return statement.

Let's rewrite our greeting function to return a value instead of printing directly:

def get_greeting(name): # This function calculates and returns a value
    return f"Hi {name}!"

message = get_greeting("Mosh") # The returned value is stored in 'message'
# Now you can do anything with 'message':
print(message) # Print it
# You could also write it to a file, send it in an email, etc.
# with open("greeting.txt", "w") as file:
#     file.write(message)

Important: If a Python function doesn't have an explicit return statement, it implicitly returns None. None is a special object in Python that represents the absence of a value.

def my_function():
    print("Hello")

result = my_function()
print(result) # Output: Hello (from the print inside my_function), then None (the default return value)

4. Keyword Arguments: Enhancing Readability

When calling functions, especially with multiple arguments, it can sometimes be unclear what each argument represents. Keyword arguments make your code more readable by explicitly naming the parameters.

def increment(number, by):
    return number + by

# Positional arguments (order matters):
print(increment(2, 1)) # Output: 3

# Keyword arguments (order doesn't matter, but readability improves):
print(increment(number=2, by=1)) # Output: 3
print(increment(by=1, number=2)) # Output: 3 (order doesn't matter with keywords)

Using keyword arguments is particularly useful when a function has many parameters or when the meaning of a positional argument isn't immediately obvious.

5. Optional Parameters: Default Values

You can make parameters optional by giving them a default value in the function definition. If the caller doesn't provide an argument for that parameter, the default value is used.

def increment(number, by=1): # 'by' has a default value of 1, making it optional
    return number + by

print(increment(2, 5)) # Output: 7 (explicitly passed 'by' value is used)
print(increment(2))    # Output: 3 (default 'by' value of 1 is used)

Rule for Optional Parameters: All optional parameters must come after all required parameters in the function definition.

# Invalid: required_param cannot come after optional_param
# def my_func(optional_param=1, required_param):
#     pass

6. Variable Number of Arguments (*args)

Sometimes, you might want a function to accept an arbitrary or variable number of arguments. You can achieve this using an asterisk (*) before a parameter name. This packs all the extra positional arguments into a tuple.

def multiply(*numbers): # The asterisk packs arguments into a tuple called 'numbers'
    total = 1
    for number in numbers:
        total *= number # Augmented assignment: total = total * number
    return total

print(multiply(2, 3, 4, 5)) # Output: 120
print(multiply(10, 2))      # Output: 20

What is a Tuple?

A tuple is similar to a list; it's a collection of objects. The main difference is that tuples are immutable, meaning you cannot modify them (add, remove, or change elements) after they are created. Tuples are defined using parentheses () (e.g., (1, 2, 3)), while lists use square brackets []. Like lists, tuples are iterable, so you can loop over them.

Important Indentation for return:

A common mistake for beginners is incorrect indentation of the return statement within a loop. The return statement should be at the same indentation level as the for loop itself if you want the loop to complete before returning. If return is inside the loop's body, the function will exit after the first iteration.

def multiply(*numbers):
    total = 1
    for number in numbers:
        total *= number
    # return total # Incorrect: If here, function returns after first iteration
    return total # Correct: Returns after the loop finishes

Conclusion

Congratulations! You've successfully navigated the foundational concepts of Python programming. We've covered:

  • Why Python is so widely used and its key advantages.
  • Setting up your development environment with Python and VS Code.
  • Writing and executing your first programs.
  • Understanding core data types like strings, numbers, and booleans.
  • Mastering string operations, formatting, and type conversions.
  • Implementing decision-making with if/elif/else and logical operators.
  • Automating tasks with for and while loops.
  • Organizing your code effectively using functions, parameters, arguments, and return values.

These are the building blocks for any Python application. You now have a solid foundation to confidently approach more advanced topics.

Next Steps:

This article is just the beginning! To deepen your Python knowledge and build more complex applications, consider exploring:

  • Data Structures: Dive deeper into lists, dictionaries, sets, and other ways to organize data.
  • Object-Oriented Programming (OOP): Learn how to create your own custom objects and classes, which is fundamental for building larger, more maintainable applications.
  • Error Handling: Understand how to gracefully handle errors and exceptions in your programs.
  • File I/O: Learn how to read from and write to files.
  • Modules and Packages: Explore how to use and create reusable code libraries.
  • Hands-on Projects: The best way to learn is by doing! Start building small projects to apply what you've learned. Think about simple command-line tools, basic games, or data processing scripts.

Keep practicing, keep building, and keep exploring. The world of Python is vast and full of exciting possibilities!

Random Expert

Leave a Reply

Your email address will not be published. Required fields are marked *

Related Articles