DEV Community: Hambolu Akintomiwa

Python Data Types and Variables

Hambolu Akintomiwa — Tue, 23 Apr 2024 10:51:20 +0000

Python has several built-in data types such as integers, floats, strings, and booleans. Variables in Python are used to store these data types and manipulate them in our programs.

Understanding these concepts is fundamental to programming in Python. In this guide, we'll explore different Python data types and variables.

Basic Data Types in Python

Basic data types in Python include Numeric Data Types, Text Data Type, and Boolean.

Numeric Data Types

There are two main numeric data types, including float, integer (int) in Python. They are used to represent numerical values and perform mathematical operations.

1. Integers (int)

Integers are data types used to represent both negative and positive whole numbers (without decimals) in Python and other programming languages.

You can use them for different mathematical operations, including multiplication, division, subtraction , and addition. The following code is an example of two variables(x and y) containing integers:

x= 50
y= 2

print(x*y)
print(x + y)

In the code above, we have multiplied as well as added the two variables using the print function. So, if you run the code on your IDE or terminal, you’ll get the following output:

100
52

2. Floats

Floats are used to represent both positive and negative numbers with decimals or fractions in Python and other programming languages.

Just like integers, you can also perform numeric operations like addition, multiplication, division, and subtraction with floating numbers. The following code multiplies and add two floating numbers.

x= 20.5
y= 2.2

print(x*y)
print(x + y)

Output:

45.1
22.7

However, you can also use integers and floats together or interchangeably if it's suitable for your Python program. Let’s take another example where you can perform numerical operations on floats and int:

x = 20.5
y = 2

print(x + y)
print(x*y)

Output:

22.5
41.0

3. Text Data Type

Str(string) is the primary text data type in Python. Strings are used to represent textual data and can contain any sequence of characters, including letters, numbers, symbols, and whitespace. The following is an example of a variable containing strings.

myString = "Hello World"

4. Booleans

Booleans are data types in Python and other programming languages used to represent truth values. They are represented by keywords such as True and False.

Booleans are fundamental in decision making and flow control within programs, as they allow for conditional statements and logical operations.

Let’s see how you can use booleans in a Python program with the following example:

raining = True
sunny = False
if raining:
   print("Don't forget to take your umbrella along")
if sunny:
   print("It's sunny outside")

In the code above, we assigned the two boolean values True and False to two different variables (raining and sunny). The if block will print any of the conditions that is true.

So, in this code, the raining variable contains the boolean value, True and will print the conditions attached. If you print the code in your terminal or IDE, you’ll get the following output:

Don't forget your umbrella

Variables in Python

Variables are considered containers where you can save different kinds of data in a Python program. Unlike Javascript, you don’t need to write any command before declaring a variable.

It's declared the moment you assign a value to it. Now, let’s declare two variables and assign values to them:

A= 47
a= 20
print(A)
print(a)

It’s very crucial to note that variables in Python are case sensitive. The fact that the both variables are of the same letter doesn’t mean they are the same. they are considered two different variables.

Python for Loop - A Beginner’s Guide

Hambolu Akintomiwa — Wed, 17 Apr 2024 09:02:23 +0000

The for loop in Python is used to iterate over a sequence, including list, tuple, string, or other iterable objects. Yet, its functionality differs from loops in languages like C++. It works similarly to the iterator methods in other object-oriented languages.

The syntax of the Python for loop is written as:

for variable in iterable:
     #statement

In the code above, the for keyword indicates the start of the loop and instructs Python to perform the action in the statement block of code on each item of the sequence (or iterable).

Also, item serves as a placeholder in the code and can be replaced with any name or word. Examples of different ways you can use the for loop are contained in the sections below.

Looping Through a List

A list in Python can contain objects such as Boolean, strings, integers, and floats and you can as well loop through all of them using the for loop.

For example, the code below prints out all the items contained in the list on a new line:

myList = [23, "life", True , 24.0, "learn"]
for i in myList:
    print(i)

The i in the code above is a variable representing all the items in the list. Also, the line for i in myList indicates that we want to access all the items contained in the variable myList.

So when you run the code above in your editor or IDE, as shown below, each of the items contained in the list will be printed on a new line.

23
life
True
24.0
learn

Let’s take another example to get a better understanding of looping through a list with a little twist. This time, we want the output to printout horizontally. We can do this by adding the end parameter.

newList = [30, 40, 70, "learn", 90]
for items in newList:
    print(items, end= " ")

This code creates a list called newList containing integers (30, 40, 70, 90) and a string ("learn"). Then, it iterates through each item in the list using a for loop. Within the loop, it prints each item followed by a space.

The end=" " parameter in the print function specifies that after printing each item, a space should be used as the separator instead of the default newline character. So, when you run this code, it will print each item in the list separated by a space, as shown below:

30 40 70 learn 90

Looping Through a Tuple

You can also loop through other sequences including Tuples, using the Python for Loop. The code below is used to print out each of the objects in the Tuple on a new line:

myTuple = ("life", 24, 75, False, 43.0, "why")
for i in myTuple:
   print(i)

It is not compulsory you use the i in the statement - you can use any letter or word in there. So, if you run the code, the following output will be shown:

life
24
75
False
43.0
why

Let us loop through a tuple with another example, without printing the output on a new line for each items (with the end parameter).

newTuple = (32, 56, "tuple", 40.2)
for items in newTuple:
    print(items, end= " ")

Output:

32 56 tuple 40.2

Looping Through a String

You can also loop through a string the same way we looped through a list and tuple above using the same syntax. The following code loops through all the characters of the string and prints each of them on a new line:

myString = "Python"
for i in myString:
      print(i)

If you run the code above, the following output will be executed:

P
y
t
h
o
n

Now let’s loop through another string with another example:

newString = "I am learning Python"
for items in newString:
     print(items, end= "")

Output:

I am learning Python

Nested for Loop

Basically, a loop within a loop is termed a nested for Loop and is supported by most programming languages including Python. It’s usually indented under the main loop. The main loop is called the outer loop, while the nested loop is called the inner loop. The basic syntax for the nested for loop is as follows:

for outer_variable in outer_sequence:
  #outer loop statement

    for inner_variable in inner_sequence:
       #inner loop statement

Nested for loops in Python allows iteration over multiple sequences within each other. The outer loop iterates through one sequence, while the inner loop iterates through another sequence for each iteration of the outer loop.

As per the syntax above, the code iterates through outer_sequence, then iterates through inner_sequence for each outer value, executing statements for the two loops.

Example: In the following code, we will use the Python nested for loop to multiply each content of the second variable y by every items in the x variable:

x = [4, 5]
y = [2, 3]
for i in x:
    for j in y:
        print(i*j)

We used the variable i to access all the items contained in x as well as j to access all the content of y and we multiplied them using the * operator.

Also, notice that the inner for loop is indented below the outer loop. If it’s not properly indented, the code will give an indentation error when you print. If you run the code, the output will be:

However, you can prevent the code from printing each outcome on different lines. You can do this by using the end parameter within the print() function.

By default, the print() function automatically adds a new line (\n) to the end of any output it prints. The end parameter allows you to stop that default behaviour.

So, if we use the end parameter on the initial nested for loop code, the code will look like this:

x = [4, 5]
y = [2, 3]
for i in x:
    for j in y:
        print(i*j, end= " ")

Output:

8 12 10 15

Notice that the output is printed out in form of a row instead of the initial column. You can also replace the spacing between the output to a comma (,) by writing it like print(i*j, end= ","). Running the code in this form will add commas between all the output.

Looping Through a Range

The for loop in Python can also be used to loop through a range of sequences with the range function (range()). It is used to generate a sequence of numbers and can take a maximum of 3 arguments (start, stop, and step size).

The default value of the first argument in the range function is (0). Meaning if not set to any number, the range will start printing from zero (0). Also, the second argument is the number where the sequence stops (usually n - 1).

Finally, the third optional argument (step size) is by default set to 1 and can be changed to any size, depending on what you want to achieve with the code. The following is the basic syntax of looping through a range of sequence:

for var_name in range(start, stop, stepsize):
        #statement

With the help of the syntax above, let’s run a simple code that will loop through the sequence of a range below:

for var in range(0,16,2):
    print(var)

The starting point of the sequence in this code is set at 0 and will iterate up to and not including 16, with a step size of 2.

However, it is not compulsory to set a step size or a starting point in your code. The default step and starting point are set at 1 and 0 respectively. So, If you run the code, the following output will be printed:

Looping Through a Range with Else and If Statements

You can also make conditional statements in your Python codes while looping through a range with the else and if statements.

As you may have known, both statements works together with some conditions. The else statement will execute based on the outcome of the if statements (true or false).

Now, let’s loop through a range with these statements:

for i in range (2,16,2):
    if i == 8:
        pass
    print(i)
else:
    print("end of the loop")

The above code is looping through a range with a starting number of 2, stopping number of 16, and 2 as the step size. If the code is without an if statement or condition, it will will run till the end down to the else block.

For a code with an if statement like the one above, the else block will on only execute based on the conditions that comes with the if block. For this code, the pass statement is a null operation; nothing happens if it is executed. It is usually used as a placeholder. Meaning, the code will run to the else block successfully.

So, if you run the code above, the following output will be executed:

2
4
6
8
10
12
14
end of the loop

However, if the if block in the code has other conditions such as break and continue instead of the pass statements, the outcome of the code will change. Let’s include the break statement into the code above and see the outcome:

for i in range (2,16,2):
    if i == 8:
        break
    print(i)
else:
    print("end of the loop")

Output:

2
4
6

Notice that the code did not run down to the else block. This is because there is a break statement in the code. The break statement executed when i == 8. So the code exited the loop prematurely and didn't reach the else block. If the break statement had not been encountered, the loop would have continued iterating through all the numbers in the specified range, and then the else block would have executed, printing "end of the loop".