Master Python data types with this comprehensive guide. Learn about numeric, string, boolean, and collection data types with examples, exercises, and tasks. Perfect for beginners and professionals to enhance their Python programming skills.
In Python, data types define the kind of value a variable can hold and the operations that can be performed on it. They act as blueprints, specifying how data is stored and manipulated in your programs.
Python Tutorial: Variables in Python
- `int`: Stores whole (non-decimal) numbers, like `10`, `-5`, or `9999`.
- `float`: Represents floating-point numbers with decimals, like `3.14`, `-2.5e2` (scientific notation), or `1.2345678901234567` (limited precision).
- `complex`: Holds complex numbers with a real and imaginary part, like `3+2j` or `1.5-4.7j`.
# Integer (int) to store age
age = 25
# Float (float) to store price with decimals
price = 14.99
# Complex number (complex) - not as common in everyday use
complex_num = 3 + 2j # Imaginary unit represented by j
- `str`: Represents textual data enclosed in single or double quotes, such as `"Hello, world!"`, `'This is a string'`, or multi-line strings using triple quotes (''' or """).
# String (str) to store a name
name = "Alice"
# String with a sentence
greeting = "Hello, how are you?"
# Multi-line string using triple quotes
message = """This is a message
that spans multiple lines."""
- `bool`: Represents logical values: `True` or `False`. Used for conditional statements and boolean expressions.
# Boolean (bool) for a true/false condition
is_raining = True
# Using booleans in an if statement
if is_raining:
print("Bring an umbrella!")
Great! Here’s your next task.
Write a Python program that:
type() function to check the data type of each number.Example Output:
The type of variable x is: <class 'int'>
The type of variable y is: <class 'float'>
The type of variable z is: <class 'complex'>
video: 3 Reasons Why Are Data Types So Important in Python
Data types are essential in Python for several reasons:
video: Is Python a Dynamic Language?
Example #: Dynamic Variables in Python
# Initial assignment of an integer value
x = 10
print(x) # Output: 10
print(type(x)) # Output: <class 'int'>
# Reassigning a string value to the same variable
x = "Hello, World!"
print(x) # Output: Hello, World!
print(type(x)) # Output: <class 'str'>
# Reassigning a list to the same variable
x = [1, 2, 3]
print(x) # Output: [1, 2, 3]
print(type(x)) # Output: <class 'list'>
# Reassigning a float value to the same variable
x = 3.14
print(x) # Output: 3.14
print(type(x)) # Output: <class 'float'>
In this example:
x is initially assigned an integer value of 10.x is then reassigned a string value "Hello, World!".x is later reassigned a list [1, 2, 3].x is reassigned a float value 3.14.Each time, the type of x changes dynamically to match the type of the value assigned to it. This flexibility is one of the powerful features of Python, allowing for more concise and adaptable code.
In Python, None is a special constant that represents the absence of a value or a null value. It is an object of its own datatype, called NoneType.
Examples:
None to Variables:
a = None
None:
if a is None:
print("a is None")
else:
print("a is not None")
In Python, type hints allow you to specify the expected data types of variables, function parameters, and return values. They make the code more readable and help developers understand what kind of values are expected.
Here’s how you can use type hints in Python:
You can add type hints to variables by using a colon : after the variable name, followed by the type:
age: int = 25
name: str = "Alice"
height: float = 5.7
is_student: bool = True
For functions, type hints are added after the parameter names and before the return type with ->.
def greet(name: str) -> str:
return f"Hello, {name}!"
# Usage
print(greet("Alice")) # Output: Hello, Alice!
This code specifies that the name parameter should be a str, and the function should return a str.
For more complex types like lists, dictionaries, sets, and tuples.
To specify that a list contains elements of a certain type, use list.
# A list of integers
numbers: list[int] = [1, 2, 3, 4, 5]
# A list of strings
names: list[str] = ["Alice", "Bob", "Charlie"]
For dictionaries, you can specify the types of both keys and values using dict.
# A dictionary with string keys and integer values
age_map: dict[str, int] = {"Alice": 30, "Bob": 25, "Charlie": 35}
To specify the type of elements in a set, use Set.
# A set of strings
unique_names: set[str] = {"Alice", "Bob", "Charlie"}
You can also use type hints in function definitions to specify the types of parameters and return values.
# Function that processes a list of integers and returns a dictionary
def process_data(numbers: list[int]) -> dict[str, int]:
result = {
'sum': sum(numbers),
'count': len(numbers)
}
return result
data = [1, 2, 3, 4, 5]
processed_data = process_data(data)
print(processed_data) # Output: {'sum': 15, 'count': 5}
Using type hints doesn’t enforce types at runtime but can improve code readability and help detect type-related issues with tools like mypy.
Incorrect Input Conversion [Python Quiz #64]
age = input("Enter your age: ")
result = age * 2
Answer Key (True/False):
What is the output of the following code? [Python Quiz #22]
age = 25
print("I am " + str(age) + " years old.")
Watch this video for the answer:https://youtube.com/shorts/DBC5-ZYoGXI?si=PXk-CPGymx2Q6X2p
age = 25
message = "You are " + str(age) + " years old."
message += " Welcome!"
print(message)
type(3 + 4.0)
- A) <class 'str'>
- B) <class 'bool'>
- C) <class 'int'>
- D) <class 'float'>
x = 10
x = "Hello"
print(type(x))
- A) <class 'int'>
- B) <class 'str'>
- C) <class 'bool'>
- D) <class 'float'>
x = 5
x = 5.0
x = True
x = "Python"
print(x)
- A) 5
- B) 5.0
- C) True
- D) Python
x = "10"
x = int(x) + 2
print(x)
- A) "102"
- B) 102
- C) 12
- D) "12"
Answer Key (Fill in the Blanks):
5 to a variable named x.10 to a variable named y.x and y to a variable named sum_xy.sum_xy.Solution:
x = 5
y = 10
sum_xy = x + y
print("Sum of x and y:", sum_xy)
pi.greeting.is_active.pi, greeting, and is_active.Solution:
pi = 3.14
greeting = "Hello, World!"
is_active = True
print("Type of pi:", type(pi), "Value:", pi)
print("Type of greeting:", type(greeting), "Value:", greeting)
print("Type of is_active:", type(is_active), "Value:", is_active)
first_name.last_name.first_name and last_name with a space in between and assign the result to a variable named full_name.full_name.Solution:
first_name = "John"
last_name = "Doe"
full_name = first_name + " " + last_name
print("Full name:", full_name)
True to a variable named is_sunny.False to a variable named is_raining.can_go_outside that is True if is_sunny is True and is_raining is False.can_go_outside.Solution:
is_sunny = True
is_raining = False
can_go_outside = is_sunny and not is_raining
print("Can go outside:", can_go_outside)
"123" to a variable named num_str.num_str to an integer and assign it to a variable named num_int.num_int.Solution:
num_str = "123"
num_int = int(num_str)
print("Type of num_int:", type(num_int), "Value:", num_int)
Basic Data Types
int), floating-point numbers (float), and complex numbers (complex).str) to represent sequences of characters.bool) for True or False.Boolean and None
NoneNone is a singleton in Python, meaning there is only one instance of None in a Python runtime. All occurrences of None point to the same object.
a = None
b = None
print(a is b) # Output: True
None is NoneType.
print(type(None)) # Output: <class 'NoneType'>
None is treated as False in a boolean context.
if not None:
print("None is considered False") # Output: None is considered False
NoneNone, use the is operator, as it checks for identity.
variable = None
if variable is None:
print("Variable is None") # Output: Variable is None
How do you check if a variable is None?
variable = None
if variable is None:
print("Variable is None")
Type Casting
[1]R. Python, “Dynamic vs Static – Real Python,” realpython.com. https://realpython.com/lessons/dynamic-vs-static/ [2]Python Software Foundation, “Built-in Types — Python 3.12.1 documentation,” Python.org, 2019. https://docs.python.org/3/library/stdtypes.html [3]“PEP 526 – Syntax for Variable Annotations | peps.python.org,” peps.python.org. https://peps.python.org/pep-0526/