Day 6: Variables and Data Types | 100 Days Python

Day 5: Comments, Escape Sequences & Print Statement | 100 Days Python

Python programming is highly intuitive for beginners, and learning the concept of variables and data types forms the foundation. This blog will walk you through these essentials, providing a structured approach for beginners to understand variables and data types in Python programming. Let’s dive in!

---

What are Variables in Python?

In Python, variables act like containers in your kitchen. Just as you use different containers to store rice, lentils, flour, or even liquids, Python variables store data within your program. These containers can hold any data, such as numbers, text, and other values, making them essential for handling and manipulating information.

Imagine you have a container that initially holds rice, and you decide to replace it with lentils. Similarly, in Python, you can reassign a variable to hold different values.

Creating a Variable in Python

Creating a variable is straightforward in Python. Simply assign a value to a variable name using the = operator, which places the value into memory.

a = 1  # Stores the integer 1 in the variable 'a'
print(a)  # Outputs 1

In this example, a is our variable name, and it currently holds the value 1. By using print(a), we instruct Python to display the value of a, which is stored in memory (specifically, in RAM).

Why Use Variables?

Variables allow us to reference data in a flexible way. Instead of hard-coding a number or text, we store it in a variable, enabling us to manipulate the information easily. This approach becomes especially useful in complex operations, where you can recall stored data by simply calling the variable name rather than re-entering values each time.

---

Data Types in Python: A Quick Introduction

Just as there are different types of contents you can put in a container—liquids, solids, powders—Python also has various data types to store different kinds of values.

Python's main data types include:

1. Integer: Whole numbers (e.g., 1, 42, -3).
2. Float: Decimal numbers (e.g., 3.14, 2.718).
3. String: Text (e.g., "Hello, World!").
4. Boolean: True/False values (e.g., True, False).
5. NoneType: Represents the absence of a value (None).
6. Complex: Numbers with real and imaginary parts (e.g., 8 + 2j).

Each data type is suited for specific operations. For instance, mathematical operations can be performed on integers and floats but not directly on strings.

---

Examples of Variable Assignments

Here’s how we assign values to variables in Python and explore different data types:

a = 1            # Integer
b = True         # Boolean
c = "Python"     # String
d = None         # NoneType
e = 8 + 2j       # Complex
f = 3.14         # Float

print(type(a))   # <class 'int'>
print(type(b))   # <class 'bool'>
print(type(c))   # <class 'str'>
print(type(d))   # <class 'NoneType'>
print(type(e))   # <class 'complex'>
print(type(f))   # <class 'float'>

Here, we see how the type() function is used to display the type of each variable, showcasing Python's versatility in handling different data.

---

Basic Operations with Variables and Data Types

Python restricts certain operations between incompatible data types. For example, adding a string and an integer will raise an error:

a = 123
b = "Python"

# This will raise an error
print(a + b)  # Error: cannot concatenate 'int' and 'str' types

To avoid such errors, ensure operations involve compatible data types. For instance, if a = 10 and b = 20, we can add them to get a + b = 30.

---

Python’s Core Data Types

Python provides a variety of built-in data types, each with specific properties:

1. Number: Includes int, float, and complex.
2. String: Text data enclosed in single (') or double quotes (").
3. Boolean: Either True or False, useful in conditional logic.
4. Sequence: Includes lists and tuples, collections that hold ordered items.

---

Lists and Tuples: A Brief Overview

Lists and tuples are collections of items that may include any data type:

• List: A mutable sequence, meaning it can be changed. Lists allow modifications like adding or removing items.

  my_list = [1, 2, "apple", 3.5]  # List with mixed data types
  my_list.append("banana")  # Adding a new item to the list
  print(my_list)

• Tuple: An immutable sequence, meaning it cannot be changed once created. Tuples are useful when you want to ensure data remains constant.

  my_tuple = (1, 2, "apple", 3.5)
  # Attempting to modify will raise an error

Dictionaries: Mapped Data

A dictionary stores data in key-value pairs, allowing you to retrieve information by its key. This is particularly useful when handling related data.

my_dict = {
    "name": "Sakshi",
    "age": 20,
    "canVote": True
}

print(my_dict["name"])  # Outputs: Sakshi

In this example, my_dict uses keys (name, age, canVote) to map to their respective values.

---

Important Insight: Everything in Python is an Object

In Python, everything is treated as an object, from integers to complex data structures like lists and dictionaries. Understanding this principle is fundamental, as it allows Python to be highly dynamic, giving flexibility to its users. Even simple data types such as int and str are objects of their respective classes.

---

Wrapping Up

In this blog, we've explored the essentials of variables and data types in Python. These building blocks pave the way for more advanced concepts in Python programming, making it critical to grasp them thoroughly. Python’s simplicity and versatility in handling different data types make it an excellent choice for beginners and experts alike.

Ready to practice? Try defining a few variables with different data types and perform operations to see Python's responses. Don’t forget to explore lists, tuples, and dictionaries to understand how to organize data effectively. Happy coding!

Buy me a Coffee

Next
Day 7: Type Casting in Python: Explicit vs. Implicit Conversion | 100 Days Python