Python Variables and Types: Harnessing the Flexibility and Versatility of Dynamic Typing

9 min readMay 26, 2023

Python is a versatile and powerful programming language that is widely used in various domains, such as web development, data analysis, machine learning, and more. One of the fundamental concepts in Python programming is variables and types. Variables allow us to store and manipulate data, while types define the nature of the data and how it can be operated upon.

You can check out the Python series for the detailed tutorial: Python Mastery: Complete Python Guide from Novice to Pro

In Python, variables serve as containers for storing values. They can hold different types of data, including numbers, strings, lists, dictionaries, and more. The flexibility of variables in Python allows for dynamic typing, meaning that variables can change their type as needed during runtime. This makes Python a highly flexible and adaptable language for various programming tasks.

If you like to know about how we can make games with the help of Python and more on “Python and Gaming” then you may like:

Python and Gaming: Predictions and Trends for 2023

To understand variables and types in Python, let’s start by exploring the different data types available in the language.

1. Numeric Types:

Python provides several numeric types to represent numbers. The most commonly used numeric types are integers (“int”) and floating-point numbers (“float”). Integers are whole numbers without decimal points, while floating-point numbers can have decimal places. Here's an example:

# Numeric Types
x = 5          # assigning an integer value to x
y = 3.14       # assigning a floating-point value to y

print(x)       # Output: 5
print(y)       # Output: 3.14
print(x+y)     # Output: 8.14

2. Strings:

Strings are used to represent textual data in Python. They are enclosed in single quotes (‘) or double quotes (“). Strings are immutable, meaning that once defined, their values cannot be changed. However, new strings can be created by manipulating existing ones. Here's an example:

# Strings
name = "Nibedita Sahu"    # assigning a string value to name
message = 'Hello, ' + name + '!'    # concatenating strings

print(name)        # Output: Nibedita Sahu
print(message)     # Output: Hello, Nibedita Sahu!

3. Lists:

Lists are a versatile data type in Python that can hold a collection of values. They are ordered and mutable, which means that elements can be added, removed, or modified. Lists are defined by enclosing comma-separated values in square brackets (‘[]’). Here's an example:

# Lists
numbers = [1, 2, 3, 4, 5]    # defining a list of numbers
fruits = ['apple', 'banana', 'orange']    # defining a list of strings
mixed = [1, 'apple', 3.14, True]    # a list with mixed data types

print(numbers)    # Output: [1, 2, 3, 4, 5]
print(fruits)     # Output: ['apple', 'banana', 'orange']
print(mixed)      # Output: [1, 'apple', 3.14, True]

print(fruits + numbers)    # Output: ['apple', 'banana', 'orange', 1, 2, 3, 4, 5]

4. Tuples:

Tuples are similar to lists, but they are immutable, meaning their elements cannot be modified after creation. Tuples are defined by enclosing comma-separated values in parentheses (‘()’). Here's an example:

# Tuples
point = (3, 4)    # defining a tuple representing a 2D point
person = ('Nibe', 20, 'nibe@example.com')    # defining a tuple representing a person's information

print(person)            # Output: ('Nibe', 20, 'nibe@example.com')
print(point)             # Output: (3, 4)
print(point+person)      # Output: (3, 4, 'Nibe', 20, 'nibe@example.com')

5. Dictionaries:

Dictionaries are used to store key-value pairs. Each value is associated with a unique key, which can be used to access the corresponding value. Dictionaries are defined by enclosing key-value pairs in curly braces (‘{}’). Here's an example:

# Dictionaries
student = {'name': 'Nibedita Sahu', 'age': 20, 'grade': 'A'}    # defining a dictionary representing a student

print(student)     # Output: {'name': 'Nibedita Sahu', 'age': 20, 'grade': 'A'}

Now that we have explored the various data types in Python let’s delve into variables and their usage.

In Python, variables are created by assigning a value to a name using the assignment operator (‘=’). Variable names can contain letters, digits, and underscores but cannot start with a digit. They are case-sensitive, meaning that ‘var’ and ‘var’ are treated as different variables. Here's an example:

# Variables
x = 7   # assigning the value 7to the variable x
message = "Hello, World!"    # assigning a string to the variable message

print(x)                # Output: 7
print(message)          # Output: Hello, World!

# Another fun
print(x + message)          # TypeError: unsupported operand type(s) for +: 'int' and 'str'
print(str(x) + message)     # Output: 7Hello, World!

Variables can be used in expressions to perform operations and store the results. They can also be reassigned to new values. Here’s an example showcasing the usage of variables:

# Variable usage
radius = 5
pi = 3.14
print(radius)             # Output: 5

# Calculating the area of a circle
area = pi * (radius ** 2)
print(area)               # Output: 78.5

# Updating the value of radius
radius = 7
print(radius)             # Output: 7

# Calculating the new area of the circle
new_area = pi * (radius ** 2)
print(new_area)           # Output: 153.86

In the above code snippet, we first assign the value 5 to the variable ‘radius’ and 3.14 to the variable ‘pi’. Then, we calculate the area of a circle using the formula ‘pi * radius²’ and store the result in the variable ‘area’. Next, we update the value of ‘radius’ to 7 and calculate the new area based on the updated radius, storing it in the variable ‘new_area’.

Variables can also be used to store the results of functions or expressions. For example, we can use variables to store the output of a mathematical calculation, the length of a string, or the result of a conditional operation. Here’s an example:

# Variable usage with functions
sentence = "The quick brown fox jumps over the lazy dog."
sentence_length = len(sentence)    # storing the length of the string in a variable

print(sentence_length)        # Output: 44

is_long_sentence = sentence_length > 50    # storing the result of a comparison in a variable
print(is_long_sentence)       # Output: False

In the code snippet above, we calculate the length of the string ‘sentence’ using the ‘len()’ function and store the result in the variable ‘sentence_length’. We then store the result of a comparison (sentence_lenght>50) in the variable ‘is_long_sentence’. This allows us to reuse these values later in the program or manipulate them further.

Python provides several built-in functions that can be used to convert variables from one type to another. These functions are useful when we need to perform operations or comparisons between variables of different types. Here are some commonly used types conversion functions:

int(): Converts a variable to an integer type.
float(): Converts a variable to a floating-point type.
str(): Converts a variable to a string type.
list(): Converts a variable to a list type.
tuple(): Converts a variable to a tuple type.
dict(): Converts a variable to a dictionary type.

Let’s look at an example to understand how type conversion works:

# Type conversion
x = 5
y = "10"
print(x+y)      # TypeError: unsupported operand type(s) for +: 'int' and 'str'

z = float(x) + int(y)    # converting x to float and y to int, then performing addition

print(z)    # Output: 15.0

#You can also try different things of your own and have fun:)

We have also discussed somewhat like this above as well. Find that one and come back again; then proceed. [If you could find the before one]. 😀

In the above code snippet, we have an integer variable ‘x’ with a value of 5 and a string variable ‘y’ with a value of "10". To perform addition, we convert ‘x’ to a float using the ‘float()’ function and ‘y’ to an int using the ‘int()’ function. After conversion, we add the two variables and store the result in the variable ‘z’. Finally, we print the value of ‘z’, which is 15.0.

Python supports dynamic typing, which means that we can change the type of a variable by assigning a value of a different type to it. This flexibility allows us to write concise and flexible code. However, it’s important to handle type conversions carefully to avoid unexpected results or errors.

In addition to the basic data types, we discussed earlier, Python provides several specialized data types and modules that extend its functionality. Some notable ones include:

* Sets:

Sets are used to store a collection of unique elements. They are defined by enclosing comma-separated values in curly braces (‘{}’). Sets are useful for tasks such as removing duplicates from a list or checking membership efficiently.

# Sets
fruits = {"apple", "banana", "orange"}
fruits.add("mango")    # adding an element to the set
print(fruits)          # Output: {'apple', 'mango', 'orange', 'banana'}

* Booleans:

Booleans represent the truth values True and False. They are often used in conditional statements and control flow. Comparisons and logical operations yield Boolean values.

# Booleans
is_raining = True
is_sunny = False

if is_raining:
    print("Take an umbrella.")     
else:
    print("That's alright!")       

if not is_sunny:
    print("Wear a jacket.")        
else:
    print("Follow your fashion!")  


# Output:
# Take an umbrella.
# Wear a jacket.

# Also try yourself by modifying the code!😊

* Modules:

Python provides a vast collection of modules that offer additional functionality beyond the built-in types. Modules are libraries of code that can be imported and used in your Python programs. Some popular modules include ‘math’ for mathematical operations, ‘random’ for random number generation, and ‘datetime’ for working with dates and times.

# Modules
import math

radius = 5
circumference = 2 * math.pi * radius    # using the math module to calculate the circumference

print(circumference)    # Output: 31.41592653589793

Check out the blog here on “math” module:

Unleashing the Power of Python’s Math Module for Data Analysis and Machine Learning

You may also be interested in knowing some other popular libraries like NumPy and pandas:

Understanding variables and types is fundamental to Python programming. Variables allow us to store and manipulate data, while types define the nature of the data and how it can be operated upon. Python offers a wide range of data types, from numeric types and strings to lists, dictionaries, and more.

You may also like to have some fun with coding, so you can check out the article on “turtle” module in Python:

Building Interactive Animations with the Turtle Module in Python

By effectively using variables and understanding their types, you can write robust, flexible, and efficient Python programs. You can perform operations, comparisons, and manipulations on variables based on their types, and Python’s dynamic typing allows for flexibility in handling different data types.