Module 2 - Variables and Basic Data Types

What's a Variable?

A variable in programming is a named location in memory that can be used to store a value. In other words, a variable is a set of characters or words that are used to store something else.  Think of it like a container for storing data, so that it can be used later in the program. For example, you could use a variable to store the user's name, the number of items in a shopping cart, or the current time. You can also change what's in the container.

To declare a variable in Python, you use the var_name = value syntax. For example, to declare a variable named name and store the value John Doe in it, you would use the following code:

name = “John Doe”

Once you have declared a variable, you can use it to store data and retrieve it later. For example, to print the value of the name variable, you would use the following code:

print(name)

This would print the following output to the console:

John Doe

Variables can be used to store any type of data, including numbers, strings, lists, and dictionaries. You can also use variables to store functions and objects.

Variables are a powerful tool that can be used to store data and make your programs more efficient. If you are new to programming, I encourage you to learn more about variables and how to use them.

Here are some additional tips for using variables:

• Choose meaningful names for your variables. This will make your code easier to read and understand.
• Use descriptive variable names. This will help you remember what each variable is used for.
• Avoid using single-letter variable names. These can be difficult to read and understand.
• Don't use reserved words as variable names. Reserved words are words that have a special meaning in the programming language.
• Use constants for values that will not change. This will make your code more readable and maintainable.
• It's also a good idea to indicate what type of data your variable contains.  More on this in the next section.

What are Data Types?

In Python, data types define the categories of the different kinds of data that can be stored in a variable. This is important, because the data type of a variable limits what can be done with it. Python provides several built-in data types, each with its own characteristics and usage. Let's explore each data type in detail and provide examples of their usage, starting with the basics. Later on, we will introduce a few other types:

Integer ('int')

Integers represent whole numbers without decimal points. They can be positive or negative. Here are some examples of how you can use integers in Python:

• You can use integers to store the number of items in a list.
• You can use integers to store the price of an item.
• You can use integers to store the age of a person.

Here's how an integer is typically defined or assigned in Python:

x = 10
y = -5

Note about Integer variables:  I like to prefix Integer variables with the letters “int” so I can easily see what data type the variable is.

Float ('float')

Float (float): Floats are numbers with decimal points. They can be represented by digits with a decimal point. For example, 1.0, 2.5, -3.14 are all floats. Here are some examples of how you can use floats in Python:

• You can use floats to store the price of an item.
• You can use floats to store the weight of an object.
• You can use floats to store the temperature of a room.

Here's how a float is typically defined or assigned in Python:

pi = 3.14
temperature = -12.5

Note about float variables:  I like to prefix float variables with the letters “float” so I can easily see what data type the variable is.

String ('str')

String (str): Strings are sequences of characters. They can be enclosed in single quotes or double quotes. Here are some examples of how you can use strings in Python:

• You can use strings to store the name of a person.
• You can use strings to store the title of a book.
• You can use strings to store the lyrics of a song.

Here's how a string is typically defined or assigned in Python:

message = "Hello, world!"
firstName = 'Bill'

Note about string variables:  I like to prefix string variables with the letters “str” so I can easily see what data type the variable is.

Boolean ('bool')

Booleans are values that can be either True or False. They are often used to represent the outcome of a test or condition. For example, True and False are both Booleans.Here are some examples of how you can use Booleans in Python:

• You can use Booleans to test whether or not a number is even.
• You can use Booleans to test whether or not a string is empty.
• You can use Booleans to test whether or not a list is empty.

Here's how a boolean is typically defined or assigned in Python:

is_raining = True
is_sunny = False

Note about boolean variables:  I like to prefix boolean variables with the letters “bool” so I can easily see what data type the variable is.

None ('NoneType')

The None type represents the absence of a value or a null value. It can be used as a placeholder, or to clear an existing value from a variable.  There are no examples of what kind of data it can be used to represent, because it literally means “nothing”

Here's how a none type is typically defined or assigned in Python:

result = None

Python supports other data types, and we will explore those later in this course.  However, we will stick with these 5 for now, so nobody gets overwhelmed with too much information too quickly.

Python Functions

Standard Python functions are functions that are built into the Python language. They are available to all Python programs without any add-ons or special commands. You can think of a function as a command that tells Python to do something. All functions require parenthesis after the function name – even if there is nothing inside them.

Parameters are variables that are passed into a function, and are placed inside the parentheses when they are used. When you call a function, you can pass it any number of parameters. The function will then use those parameters to perform its task.

For example, the print() function can be used to print text to the console. The print() function has one parameter, which is the text that you want to print. For example, the following code prints the text "Hello, world!" to the console:

print("Hello, world!")

In this example, the print() function is called with one parameter, which is the string "Hello, world!". The print() function will then print the string to the console.

Parameters can be any type of variable, including strings, numbers, and other data types. 

The type() Function

The type() function in Python is used to get the type of an object. When you call the type() function, it will return the type of the object that you pass it.

For example, the following code gets the type of the variable name:

name = “John Doe”
print(type(name))

In this example, the type() function is called with the variable name. The type() function will then return the type of the variable name, which is str.

The type() function can be used to get the type of any object in Python. This can be useful for debugging or for understanding how an object works.

The type() function is a very simple function, but it can be very useful. By learning how to use the type() function, you can gain a better understanding of how Python works.

Here are some examples of how the type() function can be used:

To get the type of a variable:

name = "John Doe"
age = 47
print(type(name))
print(type(age))

The input() Function

The input() function in Python is used to get input from the user. When you call the input() function, it will prompt the user to enter some text. The text that the user enters will be returned by the input() function.

For example, the following code prompts the user to enter their name and then prints the name to the console:

name = input("What is your name? ")
print("Hello, " + name + "!")

In this example, the input() function is called with a parameter for the prompt. The prompt is the text that will be displayed to the user. The input() function will then return the text that the user enters.

The input() function can be used to get input from the user for any purpose. For example, you could use the input() function to get input from the user for a password, a number, or a choice of options.

The input() function is a very versatile function that can be used in many different ways. By learning how to use the input() function, you can make your Python programs more interactive.

Look at you go! Just like that, you know 3 functions!

Formatting Strings

You might notice that above, a variable was added to a string inside the print function using the following syntax:

strName = “Bill”
print("My name is" + strName)

While this generally works fine in simpler applications, you could run into errors if you try this with a variable that isn't a string.  It can also get a bit messy and confusing if you have a lot of variables that you want to splice into a string.  A better way to do this in Python is through the use of formatted strings.

In Python, there are two ways to print formatted strings: f-strings and the string.format() method.

String.format() Method

The string.format() method is a more traditional way to format strings in Python. To use the string.format() method, you pass the string to the string.format() function and then use curly braces ({}) to specify the locations where expressions should be inserted. The expressions will be evaluated and replaced with their values when the string is formatted.

For example, the following code prints the string "Hello, {strName}!", where the value of the variable name is substituted for the placeholder {strName}:

strName = "John Doe"
print("Hello, {}".format(name))

F-strings

F-strings are a new feature in Python 3.6 that allow you to embed expressions in strings. F-strings are more concise and readable than the string.format() method, and they are also more efficient.

To use an f-string, simply prepend the string with the letter f. Then, you can embed expressions in the string by using curly braces ({}). The expressions will be evaluated and replaced with their values when the string is printed.

For example, the following code prints the string "Hello, {strName}!", where the value of the variable name is substituted for the placeholder {strName}:

strName = "John Doe"
print(f"Hello, {strName}!")

Which Method Should You Use?

In general, you should use f-strings whenever possible. F-strings are more concise, readable, and efficient than the string.format() method. However, if you need to support Python versions older than 3.6, you will need to use the string.format() method.

Here is a table that summarizes the differences between f-strings and the string.format() method:

Try It: Printing Basics

Let's try some things with formatted strings in the code editor below:

First, type the following lines of code, pressing enter after each one:

strName = “Sally”
strColor = “Purple”
intAge = 42

Now, let's use a couple of these in an f-string by typing the following. Press shift-enter to run the code:

print(f"My name is {strName} and I am {intAge} years old.")

Try some of the following challenges on your own:

1. Can you make up a sentence using the color and another variableA named location in memory used to store a value in programming.?
2. Can you make it work using print.format() instead of an f-string?