1.5 Writing Your First Python Program

Introduction

Now that Python and PyCharm are installed on your computer, it is time to write and execute your first Python program using PyCharm.

In this section, you will learn:

1. How to write a basic Python program in PyCharm
2. Creating and running a Python script within an IDE
3. Understanding the print() function
4. Adding comments in Python

By the end of this lesson, you should have successfully written and executed your first Python program using PyCharm.

You should also have a clear understanding of what your code does.

1.5.1 Running Python in PyCharm

While Python provides an interactive shell (called REPL), we will primarily use the PyCharm IDE as our environment for writing and running code. PyCharm comes with an integrated Python console if you still want to run one-off commands, but let’s start with the basics of managing an entire Python file in a project.

Opening PyCharm and Creating a New Project

1. Launch PyCharm from your applications.
2. On the Welcome screen (or the File menu if you already have a project open), choose New Project.
3. Choose your Python interpreter (the one you installed in the previous chapter) if prompted.
4. Pick a location for your project and click Create.

PyCharm will create a new project folder with default settings.

1.5.2 Writing a Python Script

A Python script is an ordinary file containing Python code, and having the file extension .py.

You will create this file now in PyCharm. Follow the steps below.

Step 1: Create a Python File

1. In PyCharm, right-click on your project folder (usually in the left panel).
2. Select New > Python File (or File, then New, then Python File).
3. Name the file hello.py.

Once created, PyCharm will open the file in the editor window. Add the following code:

# This is my first Python program
print("Hello, World!")

Step 2: Running the Python Script in PyCharm

1. Look for the Run option at the top menu or right-click on the file in the project explorer.
2. Choose Run ‘hello’ (PyCharm automatically detects the file name).
3. The Run panel (usually at the bottom of PyCharm) will display your program’s output.

Output:

Hello, World!

Congratulations! You have successfully written and executed your first Python program in PyCharm. Next, lets explore the print() statement as you would be using it very frequently. It is essentially a function since it can be called and passed a parameter in the brackets.

1.5.3 Understanding the print() Function

In Python, the print() function is one of the most commonly used tools for communicating information back to you (the developer) and others who might read your program’s output.

Anything you pass to print() – such as text, variables, or expressions – will be displayed in the console. In PyCharm, that is typically the Run or Console tab.

Why Use print()?

Apart from being a clear and short instruction, the print() statement provides the following benefits.

• • Immediate Feedback: print() is a quick way to see the results of computations or the values of variables, making it invaluable for testing and debugging.
  • Communication: It helps convey messages or data to users – for example, prompts, status updates, or results of a script.
  • Debugging: You can insert print() statements to trace the flow of execution, see intermediate values, and locate potential issues in your code.

Basic Usage

Below are examples of basic uses of the print() statement.

# Printing a string
print("Welcome to Python!")

Output:

Welcome to Python!

Printing Numbers and Expressions

# Printing numbers directly
print(5)
# Printing the result of an expression
print(10 + 20)

Output:

5
30

Printing Multiple Values

print("My name is", "Alice", "and I am", 25, "years old.")

Output:

My name is Alice and I am 25 years old.

Additional print() Features

• Custom Separators: You can change the default space separator by specifying the sep parameter (for example, print("A", "B", "C", sep="-") will output A-B-C).
• End Characters: By default, print() ends with a newline. You can change this using the end parameter (for example, print("Hello", end="") will continue printing on the same line).

Key Takeaways

1. The print() function is essential for both displaying information to the user and aiding in debugging.
2. You can print text, numbers, expressions, and multiple arguments in a single call.
3. Python’s default behaviour includes a space between multiple arguments and a newline at the end, but these are customisable.

1.5.4 Using Comments in Python

Comments are lines or blocks of text in your code that Python completely ignores during execution. Despite being ignored by the interpreter, comments are crucial for making your code understandable to you and others – both now and in the future.

Why Are Comments Important?

• • Clarity: Comments help explain why you wrote a piece of code in a specific way, which can save time and confusion later.
  • Collaboration: If you are working in a team, well-placed comments guide other developers through your logic, making it easier to update or extend your code.
  • Debugging & Maintenance: You can quickly identify the purpose of certain lines or sections, simplifying troubleshooting and modifications.
  • Documentation: Comments can serve as a form of inline documentation, especially important when returning to the project after a long break.

Single-Line Comments (#)

You can insert a single-line comment by starting the line (or the end of a line) with the hash symbol (#).

It is often good practice to leave a space after the # for better readability.

# This is a comment
print("Hello, World!")  # This prints a message

• Place single-line comments above or alongside code to describe what’s happening.
• You can also use multiple hash symbols to visually separate sections of code if it helps organize your file (e.g., ######### Section 1 #########).

Multi-Line Comments (""" """ or ''' ''')

Multi-line comments allow you to create blocks of descriptive text without prefixing each line with #. They’re handy when you need to add explanations or instructions that span multiple lines.

"""
This is a multi-line comment.
It is useful for adding long explanations
or describing complex logic.
"""
print("This is a Python program.")

• Surround the block of text with triple quotes (""" or ''').
• Use them sparingly; if your explanation is very long, consider using a dedicated documentation file or docstring conventions for functions and classes.

Best Practices for Commenting

• • Explain the “Why”: Focus on why the code exists or why a particular approach is taken, rather than stating the obvious “what.”
  • Be Concise: Keep comments short and to the point. Excessive or redundant text can clutter your code.
  • Stay Updated: Update comments if you change the code they refer to; outdated comments can be more confusing than no comments at all.
  • Use Consistent Style: Follow a consistent commenting style (e.g., always leaving a space after the #). This makes your code more readable and professional.

By thoughtfully incorporating single-line and multi-line comments, your programs will remain clear, maintainable, and easy to navigate – even as they grow more complex.

1.5.5 Variables and Printing User Input

Variables are a fundamental concept in any programming language, including Python.

They act as containers that hold information which can change over time or remain constant throughout the program, depending on how they are used. Variables make your code flexible, allowing you to store, manipulate, and reference data as your program runs.

Why Are Variables Important?

• • Reusability: Instead of typing the same value multiple times (e.g., a name, an ID, or a calculation), you can store it in a variable and use it throughout your program.
  • Readability: Well-named variables clarify what your code is doing. For instance, a variable called age is more descriptive than using a raw number.
  • Maintainability: If you need to change a value (such as a tax rate or a user’s name), you only need to modify the variable’s value once, rather than in multiple places.
  • Dynamic Content: Variables can store user inputs, calculations, data from a file, or output from other parts of your code, making your programs interactive and responsive to different conditions.

Storing and Printing Variables

name = "Alice"
age = 25
print("Hello, my name is", name, "and I am", age, "years old.")

• name and age are variables that store a string ("Alice") and an integer (25), respectively.
• When you run this code, Python substitutes the values of name and age inside the print() function.

Output:

Hello, my name is Alice and I am 25 years old.

Taking User Input and Printing a Greeting

name = input("Enter your name: ")
print("Hello,", name, "welcome to Python programming!")

1. input() prompts the user for text, storing whatever is typed into the variable name.
2. The print() function then uses the value in name to display a personalized greeting.

When you Run this script in PyCharm, the console will prompt for your name, then print a greeting. This simple example demonstrates how variables enable your program to respond dynamically to user input.

Key Takeaways:

1. You can store different kinds of data (text, numbers, etc.) in variables.
2. Choose descriptive variable names (e.g., user_name, total_cost, is_logged_in) to make your code self-explanatory.
3. Variables allow your program to handle different values without changing the overall structure of your code.

1.5.6 Errors and Debugging

Programming errors happen to everyone, especially when you are starting out.

Knowing how to spot and fix them quickly is an essential skill for any developer. In Python, one of the most common types of errors is the syntax error, which indicates that you have written code in a way that Python does not understand.

Common Causes of Syntax Errors

1. Missing or Mismatched Quotes: Every opening quote must have a corresponding closing quote.
2. Unclosed Parentheses/Brackets: Always check that every ( has a matching ), and similarly for [ ] or { }.
3. Indentation Mistakes: Python relies on indentation to define code blocks, so inconsistent spacing can trigger errors.
4. Typographical Mistakes: Even a small typo can cause a syntax error.

Example: Syntax Error

print("Hello, World!)  # Missing closing quote

When you run this, PyCharm (or Python in general) will return an error:

SyntaxError: EOL while scanning string literal

What Does This Mean?

• EOL stands for end of line. Python reached the end of the line (or file) and was still looking for the matching quote.

Fixing Syntax Errors

1. Check Quotes: Ensure all opening quotes have matching closing quotes (" " or ' ').
2. Check Parentheses: Make sure every parenthesis is correctly opened and closed.
3. Use PyCharm’s Hints: PyCharm often highlights syntax errors with red underlines before you run your code.

print("Hello, World!")  # Corrected version with matching quotes

Tip: If multiple errors appear, fix them one at a time. For each fix, re-run your code to confirm that you have resolved the specific error. Then move to the next one.

Beyond Syntax Errors

Other common errors that occur apart from syntax errors are:

• Runtime Errors: Occur while the program is running (e.g., dividing by zero, accessing a variable that does not exist).
• Logic Errors: Happen when the code runs without crashing but produces incorrect results. This is often a more difficult error to fix.

Debugging means identifying why the error is happening and applying a suitable fix. As you gain more experience, you will become quicker at spotting these pitfalls and preventing them from occurring.

1.5.7 Summary

In this lesson, we have covered the following:

1. PyCharm provides a convenient interface for writing and running Python scripts.
2. You can create a Python file (.py) and execute it directly within PyCharm.
3. The print() function displays text and variables in the PyCharm console.
4. Comments (#) help document your code for clarity.
5. Python can accept user input with input().
6. Syntax errors occur when the code is written incorrectly (missing quotes, parentheses, etc.).

What’s Next?

In the exercise, you will have the opportunity to practice writing your own Python scripts using the knowledge that you have gained so far.