Defining Data Types
In Python, although the language is dynamically typed, meaning you don’t need to explicitly declare the type of a variable, you can influence the data type of variables by initializing them with specific values or using type conversion functions. You can also use type annotations to document the expected types in functions and variables.
Assigning Values and Defining Types
When you assign a value to a variable in Python, the variable’s type is automatically determined based on the assigned value. Here are some examples:
Examples:
- Integers:
x = 10 # x is of type int
- Floats:
y = 3.14 # y is of type float
- Strings:
z = "Hello" # z is of type str
- Lists:
a = [1, 2, 3] # a is of type list
- Dictionaries:
b = {"name": "Alice", "age": 30}
# b is of type dict
Converting Data Types
Python provides several built-in functions to convert variables from one type to another. These functions are particularly useful when you need to ensure that data is of the correct type before performing operations.
Conversion Functions:
- int(): Converts to an integer.
x = int(3.7) # x = 3
y = int("42") # y = 42
- float(): Converts to a float.
a = float(3) # a = 3.0
b = float("2.5") # b = 2.5
- str(): Converts to a string.
i = str(100) # i = "100" j = str(3.14) # j = "3.14"
- list(): Converts to a list.
k = list("abc") # k = ['a', 'b', 'c']
l = list((1, 2)) # l = [1, 2]
- tuple(): Converts to a tuple.
m = tuple([1, 2, 3]) # m = (1, 2, 3)
- set(): Converts to a set.
n = set([1, 2, 2, 3]) # n = {1, 2, 3}
- frozenset(): Converts to an immutable set.
o = frozenset([1, 2, 2, 3]) # o = frozenset({1, 2, 3})
- dict(): Converts to a dictionary (often used with key-value pairs).
p = dict([(1, 'a'), (2, 'b')]) # p = {1: 'a', 2: 'b'}
Using Type Annotations
Although Python is dynamically typed, type annotations (introduced in PEP 484) allow you to provide hints about the types expected in functions and variables. This helps with code clarity and can be used by static type checkers.
Annotations for Variables:
Since Python 3.6, you can add type annotations to variables. However, note that these annotations are mainly for documentation and do not change the dynamic behavior of typing in Python.
age: int = 30 height: float = 1.75 name: str = "Alice"
Annotations for Functions:
Type annotations for functions specify the types of parameters and return values.
def add(a: int, b: int) -> int:
return a + b
def greet(name: str) -> str:
return f"Hello, {name}"
Practical Examples of Type Conversion
Example 1: User Input Conversion
User inputs are typically processed as strings. You may need to convert them to other types for numeric or logical operations.
# Ask the user for a number
age = input("How old are you? ") # age is a string
age = int(age) # Convert to integer
print(f"You are {age} years old.")
Example 2: Handling Types in Functions
When working with different data types in a function, you can use conversions to ensure that operations are performed correctly.
def convert_and_add(value1: str, value2: str) -> float:
try:
# Convert strings to floats
number1 = float(value1)
number2 = float(value2)
return number1 + number2
except ValueError:
return "Error: The provided values are not numbers."
print(convert_and_add("3.5", "4.5")) # 8.0
print(convert_and_add("3.5", "abc")) # Error: The provided values are not numbers.
Summary
- Assigning Values: The type of a variable is automatically defined based on the value assigned.
- Type Conversion: Use built-in functions like int(), float(), str(), list(), tuple(), etc., to convert between types.
- Type Annotations: Use these to provide hints about the expected types, improving code clarity and static type checking.
- Practical Handling: Convert types as needed and use annotations to clarify types in functions.