Step 1: Download and Install Python

1. Download Python

1. Head to the official Python download page.

2. You should see a big yellow button labeled “Download Python 3.x.x” (the latest version number). Click it to start the download.

   

2. Install Python

1. Open the downloaded installer file.
2. Important: Check the box that says “Add Python to PATH”. This makes running Python from the command line easier.
3. Choose Install Now and let the installer run.

4. Once the installation finishes, click Close.

   

3. Verify the Installation

To confirm Python is installed correctly: 1. Open Command Prompt (search “cmd” in the Start menu). 2. Type python --version and hit Enter. – If installed correctly, you should see the Python version number displayed.

Step 2: Download and Install Visual Studio Code (VSCode)

1. Download VSCode

1. Go to the VSCode download page.

2. Choose the Windows option to start the download.

   

2. Install VSCode

1. Open the downloaded installer file.
2. Follow the on-screen instructions, and when you reach the setup screen, check the following boxes:
   • Add “Open with Code” action to Windows Explorer (optional but useful).
   • Add to PATH (recommended for terminal usage).

3. Continue with the installation, and when it’s complete, click Finish.

   

Step 3: Set Up Python in VSCode

1. Open VSCode and Install the Python Extension

1. Launch VSCode.
2. Go to the Extensions sidebar (click the four-square boxes icon or press Ctrl+Shift+X).
3. Search for Python and select the one by Microsoft.

4. Click Install to add the Python extension.

   

2. Verify Python Extension in a New File

1. Create a new file by clicking File > New File.
2. Save it as test.py.

3. Type a simple line of code like print("Hello, Python!") and save the file.

   

3. Run Python Code in VSCode

1. Right-click on the code and choose Run Python File in Terminal. This will open a terminal at the bottom of VSCode and execute the code.

   • You should see Hello, Python! printed in the terminal.

   

That's It!

🎉 Congratulations! You now have Python and VSCode fully set up on your Windows computer!

Keep coding, and check back for more guides to improve your development experience.

Further Reading

Why Catching All Exceptions is a Bad Idea in Python

#blog #python #vscode #tutorial #programming #joeymanani

Sidenote

The application I used to simulate the screenshots was the Windows Sandbox – similar to a VM – and can be installed on your host machine in the builtin program Turn Windows features on or off inside of your start menu.

I realised that I can use FFmpeg to convert PNG screenshots to WebP to compress them and optimize webpage load times. Pretty cool!

Example Python traceback | Joey Manani

1. The Risk of Masking Bugs

One of the most dangerous aspects of catching all exceptions is that you may unintentionally hide bugs in your code. When you use a broad except clause like this:

try:
    # some risky code that could produce many errors
except Exception:
    pass  # Catching all exceptions

You’re ignoring the actual error, which essentially masks what went wrong. If you don’t see the error, how can you fix it? The issue may lie somewhere deeper in your logic, and by swallowing the exception, you're potentially missing valuable debugging clues as well as providing ambiguous feedback to users about what failed.

2. Makes Debugging Harder

By catching all exceptions, you're reducing the amount of information you can use to debug your program. In the worst case, a pretty vague except Exception could make you miss critical errors that would be more obvious if they weren’t caught.

You need the ability to identify specific errors and address them in a targeted way. For example, catching specific exceptions such as ValueError, TypeError, or FileNotFoundError gives you better control and clearer insight into the problem.

Example:

Instead of this:

try:
    # Open a file
except Exception:
    pass  # Ignoring all errors

You should handle specific exceptions (yes, you can chain them!):

try:
    # Open a file
except FileNotFoundError:
    print("The file doesn't exist!")
except IOError:
    print("There was an error opening the file!")

Now, the program provides more useful feedback for when something goes wrong.

3. A False Sense of Security

Catching every exception may create a false sense of security, thinking that you’ve “handled” the errors, but that's not really the case. When you swallow exceptions, you don't know how the application behaves under real error conditions. Sometimes, what you're doing is delaying the problem rather than addressing it directly causing a headache down the line.

Additionally, if the exception is silent, you may not notice issues until they snowball into something bigger, potentially causing bigger failures later.

4. Best Practices for Handling Exceptions

Instead of catching all exceptions, follow these practices:

1. Catch Specific Exceptions: Always try to handle specific exceptions instead of using a generic except Exception. This gives you better control over the errors you expect.

   Example:

   try:
       result = 10 / 0
   except ZeroDivisionError:
       print("You can't divide by zero!")
   

2. Log the Exceptions: Even if you must catch all exceptions, ensure you log the error somewhere to help with debugging later.

   Example:

   import logging
   
   try:
       # Risky code
   except Exception as e:
       logging.error(f"An error occurred: {e}")
   

3. Use Finally for Cleanup: If you need to clean up resources (like closing a file), always use a finally block. This ensures cleanup happens whether or not an exception is raised.

   Example:

   try:
       # Risky code
   except ValueError:
       print("Oops, something went wrong!")
   finally:
       print("Cleanup done!")
   

Conclusion

In summary, catching all exceptions is like applying a bandage to a broken leg— it's not the greatest of solutions, and it may cause more harm than good. By catching specific exceptions and handling them intelligently, you'll write more robust, debuggable code that enhances the user experience.

#blog #python #programming #joeymanani