What Are Data Types in Python With Examples?

Python String Data Type

Strings in Python are fundamental data types used to represent sequences of characters. They are versatile and widely used for storing and manipulating textual data. You can create strings using either single quotes ('), double quotes ("), or triple quotes (''' or """). 

Here is an example of a string in Python:

# Create strings using different quotes
message1 = 'Hello, world!'  # Single quotes
message2 = "This is a string with double quotes."
message3 = """This string spans multiple lines using triple quotes."""
# Print on separate lines
print("Messages:", message1, message2, message3, sep="\n")  

# Access characters using index
first_letter = message1[0]  # first_letter will be 'H'
last_word = message2[-4:]  # last_word will be "quotes." (slice up to, but not including, index -4)
print("First letter:", first_letter)
print("Last word:", last_word)

# String Slicing and Concatenation
greeting = message1[:5]  # greeting will be "Hello"
place = "world" #place will be “world”
full_message = greeting + ", " + place + "!"
print("Full message:", full_message)

# String methods - upper and lower case
uppercase_message = message1.upper()  # uppercase_message will be "HELLO, WORLD!"
lowercase_message = message2.lower()
print("Uppercase:", uppercase_message)
print("Lowercase:", lowercase_message)

# Find and replace
replaced_message = message3.replace("string", "sentence")  # Replace first occurrence
print("Replaced string:", replaced_message)

# Formatted string (f-string)
name = "Bob"
age = 25
greeting_fstring = f"Hi, {name}. You are {age} years old."
print(greeting_fstring)

Python Numerical Data Type

Numbers or Numeric data types in Python are used for representing numerical values and performing calculations. Here's a breakdown of the three main numeric data types:

• Integers (int): Integers are the data types that represent the whole numbers (positive, negative, or zero). In Python, integers generally have unlimited precision, meaning they can store large or small whole numbers.

Example: age = 30population = 1234567

• Floating-Point Numbers (float): Float represent real numbers with a decimal point. The range of float is approximately 3.4E-38 to 3.4E+38. 

Example: pi = 3.14159  # Approximation of pigravity = 9.81  # Meters per second squared

• Complex Numbers: Complex numbers show the values with real and imaginary parts. The imaginary value is denoted by a letter and real through a number. 

Example: z = 3 + 2j  # Real part is 3, imaginary part is 2

Python Boolean Data Type

The Boolean data type represents logical values, specifically True or False. It's fundamental for making decisions and controlling the flow of your program based on certain conditions.

Below is an example of a Boolean data type:

is_loggedIn = True  # Assigning True to a variable
age = 25
is_adult = age >= 18  # Assigning True/False based on a comparison

if is_loggedIn:
    print("Welcome back!")  # Code executes if is_loggedIn is True

if is_adult:
    print("You are eligible to vote.")
else:
    print("You are not yet eligible to vote.")  # Code executes based on is_adult value

However, in addition to these data types, Python also supports mutable data types such as dictionaries, sets, and lists and immutable data types like tuples. The below section will give you a detailed description of these data types with examples. 

Dictionaries 

A Python dictionary is a collection of elements. However, it stores the items in a key-value format. Here, the key is a unique identifier for its associated value, while the value can be any type of data you want to store in a dictionary. Two common ways to create a dictionary are by ‘{}’ separated by a comma or using a dict() function. 

Here is an example showcasing various dictionary operations: 

# Create a dictionary to store student information
student = {
  "name": "Alice",
  "age": 18,
  "course": "Computer Science",
  "grades": [85, 90, 78]  # List as a value
}

# Accessing values using keys
name = student["name"]
age = student["age"]

print(f"Student Name: {name}")
print(f"Student Age: {age}")

# Modifying a value
student["course"] = "Data Science"  # Change course

# Adding a new key-value pair
student["scholarship"] = True

# Iterating through key-value pairs
for key, value in student.items():
  print(f"{key}: {value}")

# Checking if a key exists
if "age" in student:
  print("Age key exists in the dictionary")

# Accessing a non-existent key (safer method)
grade = student.get("grade", "Not Found")  # Returns "Not Found" if key doesn't exist
#Assuming grades is a list
print(f"Average Grade: {sum(student['grades']) / len(student['grades'])}")

Sets 

Sets in Python are the unordered collection of unique data elements. You can modify the overall collection of elements in a set but cannot change the individual items stored in it. For instance, if you add a string ‘apple’ to a set, you cannot change it to ‘orange’ later within the set. 

The example below demonstrates creation, modification, membership checking, and finding intersections with other sets.

# Create a set of fruits
fruits = {"apple", "banana", "cherry"}

# Print the set (order may differ each time)
print("Original fruits:", fruits)

# Check if an element exists (membership checking)
if "mango" in fruits:
  print("Mango is in the set")
else:
  print("Mango is not in the set")

# Add a new element
fruits.add("mango")
print("Fruits after adding mango:", fruits)

# Remove an element
fruits.remove("cherry")
print("Fruits after removing cherry:", fruits)

# Find the intersection with another set (common elements)
vegetables = {"potato", "tomato", "carrot"}
common_items = fruits.intersection(vegetables)
print("Common items between fruits and vegetables:", common_items)

Lists 

Lists in Python are suitable for storing collections of items in a specific order. You can access these elements based on their position (index) in the list. Lists are heterogeneous, as they can hold different data types (like strings, numbers, or even other lists) within the same list. 

Here is an example of creation and modification in a list: 

# Create a list of numbers
numbers = [1, 5, 8, 2]

# Print the list
print("Original numbers:", numbers)

# Access an element using index
second_number = numbers[1]  # second_number will be 5
print("Second element:", second_number)

# Add an element to the end
numbers.append(10)
print("Numbers after adding 10:", numbers)

# Insert an element at a specific index
numbers.insert(2, 3)  # Insert 3 at index 2
print("Numbers after inserting 3:", numbers)

# Remove the first occurrence of an element
numbers.remove(2)
print("Numbers after removing first 2:", numbers)

# Remove and get the last element
last_item = numbers.pop()
print("List after popping:", numbers)
print("Popped item:", last_item)  # last_item will be 10

# Sort the list in ascending order
numbers.sort()
print("Numbers sorted in ascending order:", numbers)

# Reverse the order of elements
numbers.reverse()
print("Numbers in reversed order:", numbers)

Tuples 

A tuple is an ordered collection of data items that cannot be changed after creation. It can be declared within parentheses with a comma in between. The example below demonstrates how you can work with tuples, considering their ordered and immutable nature. 

# Create a tuple of colors
colors = ("red", "green", "blue")

# Print the tuple
print("Colors:", colors)

# Access an element using index
first_color = colors[0]  # first_color will be "red"
print("First color:", first_color)

# Trying to modify a tuple element (results in an error)
# colors[1] = "yellow"  # This will cause an error

# You can create a new tuple with modifications
modified_colors = colors + ("yellow",)  # Notice the comma after "yellow" for a single-element tuple
print("Modified colors:", modified_colors)

# Slicing works with tuples for extracting a portion
summer_colors = colors[0:2]  # summer_colors will be ("red", "green")
print("Summer colors:", summer_colors)

# Looping through elements
for color in colors:
  print("Color:", color)

Method 1: Using the type() Function

Python type() is a built-in function that allows you to find the class type of the variable given as input. You have to place the variable name inside the type() function, which outputs the data type.

Here is an example:

a = 60
b = "Hello"
c = 72.34
d = [4, 5, 6]

print(type(a))  # Output: <class 'int'>
print(type(b))  # Output: <class 'str'>
print(type(c))  # Output: <class 'float'>
print(type(d))  # Output: <class 'list'>

Method 2: Using the isinstance() Function

The isinstance() function in Python checks if an object belongs to a specific data type or class. It returns a boolean value, True or False, based on whether the object matches the specified type.

Here is an example:

a = 97
b = 22.65
c = "Python"

print(isinstance(a, int))	# Output: True     
print(isinstance(b, float))	# Output: True  
print(isinstance(c, str))	# Output: True

Method 3: Using the __class__ attribute

In Python, the __class__ attribute provides information about the class type of an object. Here's an example code that demonstrates how to use the __class__ attribute to obtain the type of a variable:

a = 25
print(a.__class__)
#<type 'int'>
 
b = "Data"
print(b.__class__)
#<type 'str'>
 
c = 83.45
print(c.__class__)
#<type 'float'>

Output
<class 'int'>
<class 'str'>
<class 'float'>

Here are some relevant resources to help you learn more about data types in Python: 

• Python Data Types
• Python Data Structures
• Python Built-in Data Types