Python Scripting Fundamentals

1. Storing Information: Variables and Data Types

At its core, a program manipulates data. A variable is a name that we assign to a location in memory used to store a piece of data. This allows us to label and refer to information throughout our script.

The video below, from the "Programming with Mosh" channel, provides a clear introduction to variables and the fundamental data types in Python.

As you saw, Python has several built-in or "primitive" data types:

• Integers (int): Whole numbers, like 10, -5, or 1000.
• Floats (float): Numbers with a decimal point, like 3.14, -0.001, or 9.99.
• Booleans (bool): Represent truth values. They can only be True or False.
• Strings (str): Sequences of characters used to represent text, enclosed in single ('...') or double ("...") quotes.

The quality and readability of your code are paramount, especially in a research context where others (and your future self) will need to understand and replicate your work. Adhering to a consistent style is crucial.

To summarize the key best practices for variable naming:

• Use descriptive names: learning_rate is better than lr.
• Use lowercase letters: student_count, not StudentCount or STUDENT_COUNT (capitalized names have special meanings we'll see later).
• Separate words with underscores: This style is called snake_case.

Here is an example combining these concepts:

# Variable assignments
model_name = "GPT-4"  # A string
version = 4.0        # A float
is_public = True     # A boolean
token_limit = 32768  # An integer




# Using the variables
print(f"Model: {model_name}, Version: {version}")
print(f"Is it public? {is_public}")

2. Directing Your Program: Control Flow

By default, a Python script executes sequentially from top to bottom. Control flow structures allow you to alter this path, enabling your program to make decisions or repeat actions based on specific conditions.

Making Decisions with if, elif, and else

Conditional statements allow your code to execute different blocks of logic based on whether a condition is true or false. The fundamental keywords are if, elif (short for "else if"), and else.

The following video provides a practical walkthrough of how to construct these statements.

To create more complex conditions, you can use the logical operators and, or, and not.

Here's a code example that uses these concepts to classify a model's parameter count:

parameters_in_billions = 175

if parameters_in_billions > 500:
    print("This is a very large model.")
elif 100 <= parameters_in_billions <= 500:
    print("This is a large model.")
elif 1 <= parameters_in_billions < 100:
    print("This is a medium-sized model.")
else:
    print("This is a small model.")

Notice the chained comparison 100 <= parameters_in_billions <= 500, which is much cleaner than writing parameters_in_billions >= 100 and parameters_in_billions <= 500.

Repeating Actions with for and while Loops

Loops are control flow structures that repeat a block of code. Python has two main types of loops: for loops and while loops.

• A for loop is used when you have a collection of items (like a list) and you want to perform an action for each item.

  
  
  
  # A list of hyperparameters to try
  learning_rates = [0.1, 0.01, 0.001, 0.0001]
  
  print("Trying the following learning rates:")
  for rate in learning_rates:
      print(rate)
  

• A while loop is used when you want to repeat a block of code as long as a certain condition remains true. It's useful when you don't know in advance how many times you need to iterate.

  
  
  
  # An example simulating model training that stops when loss is low enough
  loss = 0.9
  epoch = 0
  
  while loss > 0.1:
      loss = loss * 0.8  # Simulate loss decreasing
      epoch += 1
      print(f"Epoch {epoch}: Loss = {loss:.4f}")
  
  print(f"\nTraining stopped after {epoch} epochs.")
  

3. Encapsulating Logic: Functions

As your scripts become more complex, you'll find yourself repeating the same blocks of code. Functions are named, reusable blocks of code designed to perform a single, specific task. They are the cornerstone of writing organized, modular, and maintainable programs.

A function is defined using the def keyword, followed by the function name, parentheses () for parameters, and a colon :. The code inside the function must be indented. The return statement is used to send a value back from the function.

Here is how you would define and use a simple function:

def calculate_accuracy(correct_predictions, total_predictions):
    """Calculates the accuracy given the number of correct and total predictions."""
    if total_predictions == 0:
        return 0.0  # Avoid division by zero
    
    accuracy = (correct_predictions / total_predictions) * 100
    return accuracy




# Use the function
acc = calculate_accuracy(85, 100)
print(f"Model accuracy: {acc}%")




# Using the early return for the edge case
acc_no_data = calculate_accuracy(0, 0)
print(f"Model accuracy with no data: {acc_no_data}%")

This function takes two arguments (correct_predictions and total_predictions), performs a calculation, and returns the result. The text in triple quotes is a "docstring," a good practice for explaining what a function does.

Conclusion

In this lesson, you established the foundational programming skills in Python. You learned how to:

• Store data using variables and understand basic types like integers, floats, booleans, and strings.
• Control the flow of your program with if/elif/else for decision-making and for/while loops for repetition.
• Encapsulate logic into reusable functions with def and return.

These concepts are the essential grammar of the Python language. Everything you build from here, no matter how complex, will be constructed from these fundamental pieces.

In our next lesson, we will build upon this foundation by exploring more powerful and expressive ways to work with functions and data structures in Python, including list comprehensions, generators, and decorators. These tools will enable you to write more concise and efficient code, a critical skill for both research and engineering.