Demo Basic Code Completion

This lesson demonstrates basic code completion workflows using GitHub Copilot. You’ll see concise, real-world Python examples where Copilot suggests small snippets, fills in common patterns (factorial, list comprehensions), helps with exception handling, and assists when using external libraries such as requests. Key search-friendly topics covered: GitHub Copilot, Python code completion, docstring-driven completion, exception handling best practices, and using the requests library.

Create the file

Create a new Python file for the examples:

jeremy@Jeremys-Mac-Studio fakedatagenerator % touch main.py
jeremy@Jeremys-Mac-Studio fakedatagenerator %

Open main.py in your editor and trigger Copilot. It will often offer inline suggestions you can accept, discard, or regenerate.

Hello World

A minimal example — accept Copilot’s inline suggestion to generate a simple main function:

def main():
    print("Hello, World!")

if __name__ == "__main__":
    main()

Run it:

jeremy@Jeremys-Mac-Studio fakedatagenerator % python3 main.py
Hello, World!
jeremy@Jeremys-Mac-Studio fakedatagenerator %

Why this is useful: Copilot excels at trivial, well-known patterns. Use these small completions to bootstrap files and test your editor setup.

Generating a factorial function

Copilot often infers intent from function names, signatures, and docstrings. Provide a clear signature or docstring to guide the model. Example: a recursive factorial implementation:

def factorial(n: int) -> int:
    """Return the factorial of a non-negative integer n."""
    if n == 0:
        return 1
    return n * factorial(n - 1)


def main():
    print(factorial(5))  # should print 120


if __name__ == "__main__":
    main()

Run to confirm:

jeremy@Jeremys-Mac-Studio fakedatagenerator % python3 main.py
120
jeremy@Jeremys-Mac-Studio fakedatagenerator %

Tip: If Copilot doesn’t complete the implementation, add a docstring or a comment describing expected behavior — this often yields a correct solution.

Extracting usernames from a list of dictionaries

Copilot suggests common Python idioms such as list comprehensions when it detects the pattern.

users = [
    {'name': 'Michael', 'id': 1},
    {'name': 'Sanjeev', 'id': 2},
    {'name': 'Jeremy', 'id': 3}
]

usernames = [user['name'] for user in users]

# Print each username
for username in usernames:
    print(username)

Run:

jeremy@Jeremys-Mac-Studio fakedatagenerator % python3 main.py
Michael
Sanjeev
Jeremy
jeremy@Jeremys-Mac-Studio fakedatagenerator %

Note: If Copilot fills the comprehension but you forget to print results, a comment like # Print each username can prompt suggestions for the loop.

Gracefully handling missing files

When working with file I/O, Copilot commonly suggests try-except blocks. Start simple and refine to specific exceptions. Example handling a missing file explicitly:

try:
    with open('data.txt', 'r') as f:
        data = f.read()
except FileNotFoundError:
    data = 'No data available'

print(data)

If you prefer a broader catch to log any error before falling back:

try:
    with open('data.txt', 'r') as f:
        data = f.read()
except Exception as e:
    print(e)
    data = 'default data'

print(data)

Run example (when the file is missing):

jeremy@Jeremys-Mac-Studio fakedatagenerator % python3 main.py
[Errno 2] No such file or directory: 'data.txt'
default data
jeremy@Jeremys-Mac-Studio fakedatagenerator %

Prefer catching specific exceptions (like FileNotFoundError) over Exception to avoid hiding unexpected bugs.

Copilot’s suggestions are helpful for common patterns, but always review and test generated code — especially exception handling — to ensure it fits your use case.

Using the requests library (install and fix errors)

If Copilot inserts imports for external libraries that are not installed, your editor or Copilot may offer quick fixes (for example, pip install). Install requests in your virtual environment or globally as appropriate:

pip install requests

A typical requests usage pattern:

import requests

try:
    response = requests.get('https://api.github.com')
    print(response.status_code)
except requests.exceptions.RequestException as e:
    print(f"An error occurred: {e}")

If you intentionally introduce an incorrect call (e.g., requests.test), Python will raise an AttributeError:

import requests

response = requests.test('https://api.github.com')  # incorrect API usage
print(response.status_code)

Running the incorrect code yields:

(venv) jeremy@Jeremys-Mac-Studio fakedatagenerator % python3 main.py
Traceback (most recent call last):
  File "/Users/jeremy/Projects/fakedatagenerator/main.py", line 3, in <module>
    response = requests.test('https://api.github.com')
               ^^^^^^^^^^^
AttributeError: module 'requests' has no attribute 'test'
(venv) jeremy@Jeremys-Mac-Studio fakedatagenerator %

Copilot Chat or inline suggestions can diagnose this and propose replacing test with get, or add a try-except wrapper as shown above. When applying Copilot edits you will usually see a diff preview — review it before accepting.

Copilot editing workflows

Copilot offers multiple ways to apply suggestions — choose the workflow that fits your review needs:

Insert at Cursor — inserts a short suggestion directly at the cursor.
Apply in Editor — replaces or modifies larger sections and shows a diff.
Copy — copy suggested code into your clipboard for manual review and paste.

Pros and cons:

Fast insertion accelerates routine edits but requires careful review.
Diff-based application is safer for larger refactors because you can inspect changes before accepting.
Copy/paste gives the most control for auditing generated code.

Quick reference table of examples

Example	What Copilot suggests	Where to look in this article
Hello World	Inline function scaffolding	Hello World
Factorial	Implementation from docstring/signature	Generating a factorial function
List Comprehension	Idiomatic list extraction	Extracting usernames from a list of dictionaries
File I/O errors	Try-except with `FileNotFoundError` or generic `Exception`	Gracefully handling missing files
External libs	Installation quick-fix and API corrections	Using the `requests` library (install and fix errors)

Summary

This article covered basic Copilot code-completion scenarios in Python:

Accepting inline completions for simple functions (Hello World).
Generating implementations from function names and docstrings (factorial).
Completing common Python idioms (list comprehensions).
Suggesting exception handling for file operations.
Helping with external libraries (install prompts and fixing incorrect API usage).
Using Copilot Chat or editor workflows to diagnose and apply fixes, with options to copy, insert, or apply edits.

When used thoughtfully, GitHub Copilot can automate repetitive work, produce syntactically correct suggestions, and speed up development — but always review and test generated code before committing.

Introduction

GitHub Copilot Basics

Prompt Engineering with Copilot

Advanced Features

Management of GitHub Copilot

Using Copilot Efficiently

Demo Basic Code Completion

Create the file

Hello World

Generating a factorial function

Extracting usernames from a list of dictionaries

Gracefully handling missing files

Using the requests library (install and fix errors)

Copilot editing workflows

Quick reference table of examples

Summary

Links and references

Watch Video

​Create the file

​Hello World

​Generating a factorial function

​Extracting usernames from a list of dictionaries

​Gracefully handling missing files

​Using the requests library (install and fix errors)

​Copilot editing workflows

​Quick reference table of examples

​Summary

​Links and references

Watch Video

Create the file

Hello World

Generating a factorial function

Extracting usernames from a list of dictionaries

Gracefully handling missing files

Using the requests library (install and fix errors)

Copilot editing workflows

Quick reference table of examples

Summary

Links and references