MODULE 1: Python Fundamentals

/ Python Crash Course for AI/ML / By

So, you’re ready to dive into the world of Artificial Intelligence and Machine Learning? Fantastic! You’ve chosen a path filled with exciting possibilities. But before you start building AI models and wrangling massive datasets, you need a solid foundation – and that foundation is Python.

This blog post is your guide to Module 1 of our “Essential Python for AI/ML” course, focusing on the core Python fundamentals you absolutely need to know. Don’t worry if you’re a complete beginner; we’ll break it down step-by-step.

Why Python for AI/ML?

Python has become the go to language of AI/ML, and for good reason:

  • Readability and Simplicity: Python’s syntax is clean and easy to understand, making it perfect for beginners and experienced programmers alike.
  • Extensive Libraries: A vast ecosystem of powerful libraries like NumPy, Pandas, Scikit-learn, TensorFlow, and PyTorch are readily available, simplifying complex AI/ML tasks.
  • Large and Active Community: A vibrant community means ample resources, support, and continuously evolving libraries to tackle any problem.

Module 1: Building Your Python Foundation

This module is all about laying the groundwork. We’ll cover the essential building blocks you’ll rely on throughout your AI/ML journey.

1. Setting Up Your Environment: Let’s Get Coding!

First things first, you need to get Python up and running on your machine. We recommend using the Anaconda distribution. Why?

  • Easy Installation: Anaconda simplifies the installation process, bundling Python, essential libraries, and a handy environment manager.
  • Jupyter Notebooks: Anaconda comes with Jupyter Notebooks, an interactive coding environment that’s perfect for learning and experimenting with Python. Imagine a digital notebook where you can write code, run it, and see the results immediately – that’s Jupyter!

Installation Tip: Head over to the Anaconda website (https://www.anaconda.com/) and follow the instructions for your operating system. Choose the Python 3 version.

You can also use Google Colab, it’s a free, cloud-based Jupyter notebook environment that allows you to write and execute Python code in your web browser. It’s specifically designed for machine learning education and research but is great for general Python development too. Colab runs entirely in cloud, so you don’t need to install anything on your local machine, you just need google account and web browser. It comes with popular python libraries preinstalled. Colab also provides free access to powerful computing resources including CPU, GPU and TPUs (Tensor Processing Units).

2. Core Concepts: Data, Variables, and Operators

Now, let’s dive into the basics:

  • Data Types: Python has several fundamental data types:
    • Integers (int): Whole numbers like 1, -5, 100.
    • Floats (float): Numbers with decimal points like 3.14, -2.5.
    • Strings (str): Text enclosed in quotes like “Hello, World!”, ‘Python is awesome’.
    • Booleans (bool): Represent truth values: True or False.

  • Variables: Think of variables as named containers that hold data. We assign values to variables using the = operator:
my_age = 30 name = "Alice"is_student = False

  • Operators: Operators allow you to perform actions on data:
    • Arithmetic Operators: + (addition), – (subtraction), * (multiplication), / (division), % (modulo – remainder), ** (exponentiation).
    • Comparison Operators: == (equals), != (not equals), > (greater than), < (less than), >= (greater than or equal to), <= (less than or equal to).
    • Logical Operators: and (logical AND), or (logical OR), not (logical NOT).

3. Control Flow: Making Decisions and Repeating Actions

Control flow statements dictate the order in which your code is executed.

  • Conditional Statements (if, elif, else): Allow your code to make decisions based on conditions.
age = 18
if age >= 18:
    print("You are an adult.")
else:
    print("You are a minor.")

  • Loops (for, while): Enable you to repeat a block of code multiple times.
# For loop
for i in range(5):  # Loops from 0 to 4
    print(i)

# While loop
count = 0
while count < 5:
    print(count)
    count += 1  # Increment count

4. Data Structures: Organizing Your Data

Python offers built-in data structures to store and manage collections of data:

  • Lists: Ordered, mutable (changeable) sequences of items. 
my_list = [1, 2, "apple", 3.14]
print(my_list[0])  # Accessing the first element (1)
my_list.append("banana")  # Adding an element

  • Tuples: Ordered, immutable (unchangeable) sequences of items.
my_tuple = (1, 2, "apple")
print(my_tuple[0])  # Accessing the first element (1)
# my_tuple[0] = 5  # This will raise an error (tuples are immutable)
  • Dictionaries: Unordered collections of key-value pairs.
my_dict = {"name": "Alice", "age": 30, "city": "New York"}
print(my_dict["name"])  # Accessing the value associated with the key "name"
my_dict["occupation"] = "Data Scientist" # Adding a new key-value pair
  • Sets: Unordered collections of unique items.
my_set = {1, 2, 3, 3, 4}  # Duplicates are automatically removed
print(my_set)  # Output: {1, 2, 3, 4}

5. Functions: Reusable Blocks of Code

Functions are named blocks of code that perform a specific task. They help you organize your code and avoid repetition.

def greet(name):
    """This function greets the person passed in as a parameter."""
    print("Hello, " + name + "!")

greet("Bob")  # Calling the function

6. Key Syntax points to note for Python programming language:

This section is going to be very helpful, if you already know any other programming language, it provides what is different in python from other languages.

Indentation is King:

  • Python uses indentation (typically 4 spaces) to define code blocks instead of curly braces {} (C++, Java, JavaScript, etc.) or begin/end blocks (Pascal). Inconsistent indentation = SyntaxError!
  • Example:
if x > 5:
    print("x is greater than 5")  # This line is part of the 'if' block
    print("Still inside the if block")
print("Outside the if block")       # This line is not

No Explicit Type Declarations:

  • You don’t need to declare the data type of variables. Python is dynamically typed, so the type is inferred at runtime.
  • Be mindful of implicit type conversions (e.g., adding a string and an integer will throw an error).
  • Example:

x = 10 # x is an integer
name = “Alice” # name is a string

No Semicolons (Mostly):

  • Python generally doesn’t require semicolons at the end of statements. Newlines are usually sufficient.
  • Semicolons can be used to put multiple statements on one line, but this is generally discouraged for readability.
  • Example:
x = 5
y = 10  # No semicolon needed

Keywords, Not Symbols:

  • Python uses keywords like and, or, not for logical operations instead of &&, ||, ! (C++, Java, etc.).
  • in is used for membership testing (e.g., if “a” in my_string:).

Colon for Block Headers:

  • Control flow statements (if, else, for, while), function definitions (def), and class definitions (class) all end with a colon :. This signals the start of an indented code block.

Comments:

  • Single-line comments start with #.
  • Multi-line comments are enclosed in triple quotes (“”” or ”’). These are often used for docstrings (documentation within the code).
  • Example:
# This is a single-line comment
"""
This is a multi-line comment
It can span multiple lines.
"""

Function and Class Definitions:

  • Use the def keyword to define functions.
  • Use the class keyword to define classes.
  • Methods within a class must have self as the first parameter. self refers to the instance of the class.
  • Example:
def my_function(arg1, arg2):
    """This is a function definition."""
    return arg1 + arg2

class MyClass:
    def __init__(self, value):
        self.value = value

    def get_value(self):
        return self.value

Truthiness:

In conditional statements, certain values are implicitly treated as True or False:

  • False: False, None, 0, empty strings (“”), empty lists ([]), empty tuples (()), empty dictionaries ({}).
  • True: Everything else.

None vs. null:

Python uses None to represent the absence of a value, similar to null in other languages.

List Comprehensions:

  • Python has a concise syntax for creating lists using list comprehensions.
  • Example:
numbers = [1, 2, 3, 4, 5]
squares = [x * x for x in numbers]  # Creates a list of squares

String Formatting:

Python offers multiple ways to format strings:

  • f-strings (formatted string literals – the preferred method): f”The value is {value}”
  • .format() method: “The value is {}”.format(value)
  • % operator (older style – generally discouraged): “The value is %s” % value

“Gotchas” for Experienced Programmers:

  • Mutability: Be aware of which data types are mutable (lists, dictionaries, sets) and immutable (strings, tuples, numbers). Modifying a mutable object can have unexpected side effects if it’s referenced in multiple places.
  • Scope: Pay attention to variable scope (global, local, nonlocal). Python’s scope rules can be different from other languages.
  • == vs. is:
    • == checks for value equality.
    • is checks for object identity (whether two variables point to the same object in memory).
    • Generally, use == for comparing values and is for checking if a variable is None.

Key Takeaways from Module 1:

  • You’ve installed Python and a coding environment (Anaconda/Jupyter).
  • You understand the fundamental data types, variables, and operators.
  • You can control the flow of your program using conditional statements and loops.
  • You can work with various data structures to store and organize information.
  • You can define and use functions to create reusable blocks of code.

Practice Makes Perfect!

Don’t just read this blog post; do the exercises! Try writing small programs to solidify your understanding. For example:

  • Write a program to calculate the factorial of a number.
  • Create a function that checks if a string is a palindrome.
  • Build a simple “guess the number” game.

What’s Next?

Congratulations on completing Module 1! You’ve taken the first crucial step towards mastering Python for AI/ML. In the next module, we’ll explore NumPy, a powerful library for numerical computing, which forms the backbone of many AI/ML algorithms. Stay tuned!

next Module 2: nummpy for AI/ML