Objective

As we continue our journey in learning Python, the next step is understanding the concept of variables and the basic data types Python provides. You will learn about strings, integers, floats, and booleans, which are the building blocks for any Python program. After gaining a basic understanding of these data types, you'll also learn how to perform operations on these variables. By the end of this unit, you'll be able to manipulate strings, perform arithmetic operations, and control the flow of your programs using boolean logic.

Python Program Structure

Python programs follow a clear structure, consisting of a sequence of instructions executed from top to bottom. The program's instructions are organized into code blocks, which are groups of statements that should be treated as a unit. These blocks are denoted by their indentation levels in Python. That means that the spaces at the beginning of lines aren't just for making the code look good and readable; they're actually a meaningful part of the code. Since code blocks can be nested, Python uses indentation to define which statements should be grouped together to form a code block that perform specific operations.

Python programs typically contain several types of statements, including:

• Assignment statements, such as x = 5, where a value is assigned to a variable.
• Control statements, such as if, for, and while, which guide the flow of the program.
• Function calls, which execute a series of pre-written statements.
• Import statements, which bring in code from external libraries.

In addition, it's good practice to include comments in your programs to clarify your code. Comments are preceded by a hash symbol (#) and are ignored by Python when it runs the script.

# This is a comment
x = 5  # This is an inline comment

Understanding Variables

Variables are containers that hold values. They are given names (identifiers), which can be used to retrieve the values they contain. In Python, you can assign a value to a variable with the assignment operator (=).

message = "Hello, Python!"
age = 17
pi = 3.14159

In the above code, message, age, and pi are variables that hold the values "Hello, Python!", 17, and 3.14159, respectively.

Data Types: String, Integer, Float, Boolean

Python has several built-in data types that can be used to represent data in your programs.

Strings

Strings represent textual data and are enclosed in either single quotes (') or double quotes (").

greeting = "Hello, world!"

Integers and Floats

Integers represent whole numbers, while floats represent real numbers (that is, numbers with a decimal point).

count = 10  # An integer
price = 19.99  # A float

Booleans

Booleans represent truth values and can be either True or False.

is_sunny = True  # It's a sunny day

Basic Operations with Strings, Integers, and Floats

You can perform various operations with these data types, such as addition, subtraction, multiplication, and division with integers and floats.

num1 = 10
num2 = 20
total = num1 + num2  # 30

With strings, you can perform concatenation (joining of two strings) using the + operator.

greeting = "Hello"
name = "Alice"
message = greeting + ", " + name + "!"  # "Hello, Alice!"

Boolean Operations

Booleans are used in operations that need to evaluate to either True or False. They are fundamental to control flow in programming as they let the computer decide between alternatives based on whether certain conditions are met.

In Python, the two constant objects False and True are used to represent truth values. These two objects are of type bool and they are built into Python.

You can perform operations with booleans, such as logical AND, OR, and NOT.

is_raining = False
is_sunny = not is_raining  # True

In the example above, the not operator negates the value of is_raining. Since is_raining is False, not is_raining is True, and this value is assigned to is_sunny.

Let's look at another example using and and or:

is_weekend = True
is_vacation = False

# You can go to the park if it's a weekend or if it's a vacation
can_go_to_park = is_weekend or is_vacation  # True

# You can sleep in if it's a weekend and it's a vacation
can_sleep_in = is_weekend and is_vacation  # False

In this example, can_go_to_park is True because is_weekend is True. The or operator returns True if at least one of its operands is True.

On the other hand, can_sleep_in is False because, even though is_weekend is True, is_vacation is False. The and operator only returns True if both of its operands are True.

In addition to these logical operations, booleans are often the result of comparison operations, such as equals (==), not equals (!=), less than (<), less than or equals (<=), greater than (>), and greater than or equals (>=).

x = 10
y = 20

is_x_equal_y = x == y  # False
is_x_not_equal_y = x != y  # True
is_x_less_than_y = x < y  # True
is_x_greater_than_y = x > y  # False

These boolean operations and comparison operators form the backbone of decision making in your Python programs.

Project: Draw a Shape Based on User Input

In this project, we'll use the Turtle library to draw a shape based on user input. We'll ask the user for the number of sides they want for their shape, and then draw it.

Here's the complete Python code:

import turtle

# Create a new turtle screen and set its background color
screen = turtle.Screen()
screen.bgcolor("white")

# Create a new turtle and assign it to a variable called "t"
t = turtle.Turtle()

# Ask the user for the number of sides.  Whatever the user
# enters is will assigned to the variable "response".
response = input("Enter the number of sides: ")

# The result of the input() function is always a string, so the
# data type of the response variable will be a `str`.  Since
# we're expecting a number, we use the int() function to convert
# the string to an integer.
num_sides = int(response)

# Draw a shape based on the number of sides
for _ in range(num_sides):
    t.forward(100)              # Move forward by 100 units
    t.right(360 / num_sides)    # Rotate the turtle direction clockwise

# We're done, so let's wait until the window is closed
turtle.done()

NOTE: When you run this code, you should see the TERMINAL panel in the bottom half of the VS Code editor open. There you'll see the prompt to enter the number of sides. After you enter a number and hit Enter/Return on the keyboard, you should see the shape drawn in the window that was open.

Remember to close the window to terminate the program.

In this code, we first import the turtle module. A module is a collection of code that can be reused in other programs. In this case, the turtle module allows us to create graphics in a window.

With this module imported, we can now access the functions it exposes. We use these functions to create a new window with a white background, and a turtle named "t". (Technically speaking, we say an instance of the Turtle object is assigned to the variable "t".) The turtle will draw on this window just like you would draw on a canvas.

The input() function is used to ask the user to input the number of sides they want for their shape. The input is then converted to an integer using the int() function.

We then use a for loop to draw the shape. The turtle moves forward by 100 units, then turns right by 360 divided by the number of sides. This happens as many times as there are sides.

Finally, we use turtle.done() to keep the graphics window open until the user closes it.

In the next unit, we'll cover arithmetic and comparison operators.