Skip to content

Essential Techniques

Beyond the basic interface and file handling, here are a few more tools and techniques crucial for your work in Colab.

Installing Python Packages

Python's power comes from its vast ecosystem of packages or libraries – collections of pre-written code that provide specific functionalities (like Polars for data manipulation, Altair for plotting, Scikit-learn for machine learning).

  • Colab's Pre-installed Packages: Colab comes pre-installed with many common data science packages (like numpy, pandas, scikit-learn, matplotlib, etc.). Often, key libraries for this course like polars and altair might also be pre-installed or install quickly on first use.

  • Installing Additional Packages: If you need a package not included by default, or want to ensure you have a specific version, you can install it using pip (Python's package installer). Prefix the command with ! in a code cell to run it as a shell command:

    # Example: Install the 'seaborn' plotting library
!pip install seaborn

# Example: Install multiple packages
# !pip install package-one package-two

# Tip: Add '--quiet' or '-q' to reduce installation output messages
!pip install missingno --quiet
    * Temporary Installation: Remember, packages installed this way are temporary for the current Colab session. If you restart your runtime, you must re-run the !pip install cell(s) for any custom packages your notebook needs. Place these commands early in your notebook for easy access.

A Note on Package Versions, API Changes, and Deprecation

Python libraries like Polars and Altair are under active development. This means they get updated frequently with new features, bug fixes, and performance improvements. However, these updates can sometimes change how the library works, which might affect code you find online or in older resources.

  • Package Versions: Libraries typically use version numbers (e.g., polars 1.2.3). These often follow a pattern like MAJOR.MINOR.PATCH:
    • PATCH changes usually indicate internal bug fixes.
    • MINOR changes typically add new features compatibly.
    • MAJOR changes often signal breaking changes.
    • You can check the installed version of a library in your Colab environment: 
      import polars
import altair

print(f"Polars version installed: {polars.__version__}")
print(f"Altair version installed: {altair.__version__}")
  • Breaking API Changes: Sometimes, library updates need to change the way existing functions or methods work (e.g., renaming a function, changing the required arguments, altering default behavior). These are "breaking changes" because code written for the older version might no longer run correctly with the newer version. Library authors try to minimize these, but they happen as libraries evolve and improve. An AttributeError (e.g., "object has no attribute 'old_function_name'") or TypeError (e.g., "function got an unexpected keyword argument 'old_argument'") can sometimes be a symptom of an API change.
  • Deprecation Warnings: Libraries often provide advance notice before making a breaking change. You might see a DeprecationWarning or FutureWarning when you run code using an older feature. This warning usually doesn't stop your code from running right now, but it's telling you "this way of doing things will be removed in a future version; please switch to the new recommended way." The warning message often suggests the alternative function or method to use.

Why This Matters for You: You might find a code example online (from a blog, tutorial, Stack Overflow, or even an older book) that doesn't work immediately in your current Colab environment. This could be because the example was written for an older version of a library like Polars or Altair, and there has been a breaking change or deprecation since then.

What to Do When Old Code Examples Break or Warn:

  1. Check Versions: Note the version of the library installed in your Colab environment (using print(library.__version__)). If the tutorial mentions a version, see if it's different.
  2. Read Errors Carefully: Look closely at AttributeError or TypeError messages – they might hint that a function or argument name has changed.
  3. Heed Warnings: Don't ignore DeprecationWarning or FutureWarning. Look up the function mentioned in the warning in the library's current documentation to find the recommended alternative.
  4. Consult Official Documentation: The current official documentation for the library (e.g., the Polars or Altair websites) is the most reliable source of truth for how the library works now. Search the documentation for the function or feature you're trying to use.
  5. Specify Versions (Use Cautiously): If you absolutely need to run an old code example as-is (perhaps just to understand it), you can try installing the specific older version the example might have used: 
    # Caution: Installs an older version, potentially missing new features/fixes
# !pip install polars==0.19.0
# !pip install altair==4.2.0
    However, do this sparingly. The better long-term approach is usually to understand the change and update the code example to work with the current library versions, using the official documentation as your guide. Relying on old library versions means you miss out on important updates and bug fixes.

Understanding that libraries evolve and knowing how to consult documentation are key skills for working with Python effectively!

Leveraging Built-in Gemini AI

As of mid-2025, Google Colab features integrated AI assistance, often leveraging models from the Gemini family. When used thoughtfully, this can significantly accelerate your learning and coding process.

  • Accessing AI: Look for AI-related icons directly within the cell toolbar (common icons include ✨, the Gemini logo, or similar). You might also find options within the Tools menu or via the Command Palette (Ctrl+Shift+P). Note: The exact interface for AI features can evolve, so familiarize yourself with the current layout. Colab cell toolbar

  • How AI Can Help You Learn:

    • Code Generation: Ask for code snippets. Example prompt: "Generate Python code using Polars to group the DataFrame 'df' by the 'category' column and calculate the average 'value'." Critically review generated code before running!
    • Code Explanation: Select a code cell (yours or one you found) and ask the AI to clarify it. Example prompt: "Explain what this block of Python code does step-by-step."
    • Debugging Assistance: If you get an error, paste the error message and ask for help. Example prompt: "Explain this Python error: NameError: name 'data' is not defined. How can I fix it?"
    • Adding Comments/Documentation: Ask the AI to document your code. Example prompt: "Add comments to this Python function explaining each part."
    • Learning from Examples: Paste code snippets from external sources (like documentation or tutorials) and ask the AI to explain them. This is a great way to deconstruct and learn new patterns. (See Section 7: Best Practices for a detailed workflow on this).

Important Considerations:

  • AI is an Assistant, Not an Oracle: AI models can make mistakes (generate incorrect code, provide inaccurate explanations). Always think critically about the output. Does it make logical sense? Does the code work correctly?
  • Prioritize Understanding: Use AI to aid your learning, not replace it. If AI generates code, strive to understand why it works that way. Ask follow-up questions.
  • Be Mindful of Data: Check Google's terms regarding data privacy if you are working with sensitive information.
  • Stay Updated: AI features change quickly. Refer to official Google Colab documentation for the latest capabilities and usage guidelines.

Basic Debugging

Writing code involves finding and fixing errors – a process called debugging. Don't be intimidated by error messages; they are valuable clues!

  • Errors are Normal: Expect to see errors, especially when learning. They don't mean you've failed; they mean the computer needs more precise instructions.

  • The Traceback: When Python code fails in Colab, it usually prints an error message and a Traceback. The traceback shows the sequence of function calls leading up to the error. It can look long, but focus on the key parts:

    1. Scroll to the Bottom: The most specific information about the error is almost always at the very end.
    2. Identify Error Type: Look for the line stating the error type (e.g., SyntaxError, NameError, TypeError, FileNotFoundError, AttributeError, ValueError, IndexError). This gives you the general category.
    3. Read the Message: The text immediately following the error type provides details about the specific problem. Read this carefully!
    4. Locate the Line: The traceback often points an arrow (---->) to the exact line in your code cell where the error was detected.

    5. Common Error Types and Meanings:

    6. SyntaxError: A typo or grammatical mistake in your Python code itself (e.g., missing colon, parenthesis, incorrect indentation). Check the indicated line meticulously.

    7. NameError: You tried to use a variable or function name that hasn't been defined yet in the current execution order. Did you run the defining cell? Did you misspell the name? (See Section 3).
    8. TypeError: You tried an operation on incompatible data types (e.g., adding text to a number).
    9. FileNotFoundError: Python couldn't find the file at the path you specified. Check the path's spelling (case-sensitive!), ensure the file exists where you think it does, and make sure Drive is mounted if applicable. Use "Copy path"! (See Section 4).
    10. AttributeError: You tried to use a method or attribute that doesn't exist for that specific object type (e.g., my_dataframe.calculate_sumz() when the method is actually calculate_sums()). Check for typos or consult the library's documentation.
    11. ValueError: The function received an argument of the correct type but an inappropriate value.
    12. IndexError: You tried to access an item in a sequence (like a list) using an index number that is out of bounds.
    13. Debugging Strategy: Read the error message -> Locate the line -> Think about what the message means in the context of your code -> Formulate a hypothesis -> Make a change -> Re-run the cell. Repeat if necessary! Use the AI assistant if you get stuck understanding an error.