How to declare primitive data types in Python

In Python, primitive data types are the fundamental building blocks for all data. To program effectively and manipulate data, you must know how to declare integers, floats, strings, and booleans.

In this article, we'll cover techniques to declare each data type. You'll get practical tips, see real-world applications, and receive advice to debug common errors for a solid foundation.

Basic declaration of primitive data types

integer_var = 42
float_var = 3.14
string_var = "Hello, Python!"
boolean_var = True
print(type(integer_var), integer_var)
print(type(float_var), float_var)
print(type(string_var), string_var)
print(type(boolean_var), boolean_var)--OUTPUT--<class 'int'> 42
<class 'float'> 3.14
<class 'str'> Hello, Python!
<class 'bool'> True

Python's dynamic typing is on full display here. You don't need to declare a variable's type beforehand; Python infers it from the value you assign. When you set integer_var = 42, Python automatically recognizes it as an integer.

The type() function confirms this behavior. The output shows that Python correctly identified the types for each variable—<class 'int'>, <class 'float'>, <class 'str'>, and <class 'bool'>—all based on their assigned values.

Common type operations

Building on basic declarations, you can also convert between types, add optional type hints for clarity, and streamline your code with multiple assignments.

Converting between primitive types with built-in functions

integer_from_str = int("42")
float_from_str = float("3.14")
str_from_int = str(42)
bool_from_int = bool(1) # Any non-zero value is True
print(integer_from_str, float_from_str, str_from_int, bool_from_int)--OUTPUT--42 3.14 42 True

Python lets you explicitly change a variable's type using built-in functions like int(), float(), and str(). This process, known as type casting, is essential when you need to perform operations on data that isn't in the right format, such as converting user input from a string to a number.

• The int() and float() functions parse strings into numbers.
• The str() function converts numbers back into strings.
• The bool() function evaluates values for truthiness—any non-zero number becomes True, while 0 becomes False.

Using type hints with primitive types

from typing import List, Dict

age: int = 30
height: float = 1.75
name: str = "Alice"
is_student: bool = False
print(f"Age: {age}, Height: {height}, Name: {name}, Student: {is_student}")--OUTPUT--Age: 30, Height: 1.75, Name: Alice, Student: False

Type hints are optional labels that declare a variable's intended data type, like age: int. It's important to know that Python doesn't enforce these hints at runtime; your code will still execute even if you assign a different type. Their main purpose is to improve code quality for developers.

• They make code self-documenting and easier for others to understand.
• Static analysis tools and IDEs use them to catch potential errors before you run the program.

Multiple variable assignments

a, b, c = 1, 2.5, "three"
x = y = z = 10 # All variables get the same value
first, *middle, last = [1, 2, 3, 4, 5] # Unpacking with *
print(f"a={a}, b={b}, c={c}")
print(f"x={x}, y={y}, z={z}")
print(f"first={first}, middle={middle}, last={last}")--OUTPUT--a=1, b=2.5, c=three
x=10, y=10, z=10
first=1, middle=[2, 3, 4], last=5

Python offers several shortcuts for assigning variables, making your code more compact. You can assign different values to multiple variables on a single line, like with a, b, c = 1, 2.5, "three". This technique is often called tuple unpacking.

• To give several variables the same value, you can chain them: x = y = z = 10.
• For more advanced list unpacking, the asterisk operator (*) is a powerful tool. In first, *middle, last, the *middle variable collects all the elements between the first and last into a new list.

Advanced type techniques

When standard int and float types aren't precise enough, Python's ecosystem provides specialized numeric types for more complex computational challenges.

Using the Decimal module for precision

from decimal import Decimal, getcontext

getcontext().prec = 10 # Set precision
d1 = Decimal('0.1')
d2 = Decimal('0.2')
regular_sum = 0.1 + 0.2
decimal_sum = d1 + d2
print(f"Regular: {regular_sum}, Decimal: {decimal_sum}")--OUTPUT--Regular: 0.30000000000000004, Decimal: 0.3

Standard float types can introduce small precision errors due to how computers handle binary arithmetic. The code shows that 0.1 + 0.2 results in an unexpected trailing 4. For calculations where accuracy is critical—like in financial applications—you should use the Decimal module.

• It performs arithmetic with exact decimal representation, avoiding common float inaccuracies.
• You initialize Decimal objects with strings, like Decimal('0.1'), to preserve their exact value.
• The getcontext().prec function lets you control the calculation's precision.

Working with complex numbers

complex_num1 = 3 + 4j
complex_num2 = complex(5, 2)
print(f"Complex number: {complex_num1}, type: {type(complex_num1)}")
print(f"Magnitude: {abs(complex_num1)}, Conjugate: {complex_num1.conjugate()}")
print(f"Addition: {complex_num1 + complex_num2}")--OUTPUT--Complex number: (3+4j), type: <class 'complex'>
Magnitude: 5.0, Conjugate: (3-4j)
Addition: (8+6j)

Python has native support for complex numbers, which are essential in many scientific and engineering domains. You can declare them directly using the j suffix, as in 3 + 4j, or with the complex() constructor. Python recognizes this as a distinct complex data type.

• The built-in abs() function calculates the number's magnitude.
• The .conjugate() method finds its complex conjugate by flipping the imaginary part's sign.
• Standard arithmetic operators like + work just as you'd expect.

Using specialized numeric types from numpy

import numpy as np

int32_array = np.array([1, 2, 3], dtype=np.int32)
float64_array = np.array([1.1, 2.2, 3.3], dtype=np.float64)
print(f"Int32 array: {int32_array}, dtype: {int32_array.dtype}")
print(f"Float64 array: {float64_array}, dtype: {float64_array.dtype}")--OUTPUT--Int32 array: [1 2 3], dtype: int32
Float64 array: [1.1 2.2 3.3], dtype: float64

For high-performance numerical tasks, Python's standard types aren't always the most efficient. The numpy library fills this gap by providing specialized numeric types that give you more control over memory and performance. When you create a numpy array, you can specify the exact data type, such as np.int32 or np.float64.

• These types are fixed-size, meaning an np.int32 always uses 32 bits. This predictability is vital for optimizing large-scale computations.
• This level of control is essential in fields like data science and machine learning, where managing memory and speed is critical for handling massive datasets.

Move faster with Replit

Replit is an AI-powered development platform where you can start coding Python instantly. All the necessary dependencies come pre-installed, so you can skip the setup and get straight to building.

Instead of just piecing together techniques, you can use Agent 4 to build a complete application from a simple description. Here are a few examples of what you could create based on the types we've covered:

• A financial calculator that uses the Decimal type to ensure precise interest calculations, avoiding common float errors.
• An engineering utility that processes signals by converting inputs to complex numbers and calculating their magnitude or conjugate.
• A data analysis script that ingests large datasets and converts them into memory-efficient numpy arrays like np.int32 for faster processing.

Simply describe your app, and Replit will write the code, test it, and fix issues automatically, all within your browser.

Common errors and challenges

Even with Python's simplicity, you'll run into common roadblocks like unexpected truncation, type errors, and invalid conversions when handling primitive types.

Avoiding integer truncation with / and // operators

A frequent source of confusion is the difference between the division operators. The single slash / performs true division and always returns a float, while the double slash // performs floor division, rounding down to the nearest whole number and returning an int if both numbers are integers.

• Using // can unintentionally truncate the decimal part of a result. For example, 7 // 2 evaluates to 3, not 3.5.
• Be mindful of this behavior, especially in calculations where precision matters. If you need an exact decimal result, always use the / operator.

Fixing TypeError when concatenating strings and numbers

Python is strongly typed, which means it won't automatically convert a number to a string during concatenation. If you try to combine a string and a number using the + operator, Python will raise a TypeError because it doesn't know whether you intend to add or concatenate.

To fix this, you must explicitly convert the number into a string using the str() function. For instance, instead of writing "Your score is: " + 100, you should write "Your score is: " + str(100) to ensure the operation succeeds.

Handling ValueError in type conversions

When you try to convert a string to a number using int() or float(), you'll get a ValueError if the string contains non-numeric characters. For example, int("twenty") will fail because the function can't parse the text as a number.

This is a common issue when dealing with user input. The best way to manage it is by wrapping the conversion in a try-except block. This allows you to "catch" the ValueError and handle it gracefully—perhaps by prompting the user again—instead of letting your program crash.

Avoiding integer truncation with / and // operators

You've seen the theory behind the / and // operators. In practice, mixing them up can silently introduce errors into your calculations, especially when you expect a precise decimal. The following code highlights how this can happen.

# Calculate average score
num_students = 10
total_score = 87
average = total_score / num_students
print(f"Class average: {average}")

# This may cause unexpected results in older Python versions
score1 = 7
score2 = 2
ratio = score1 / score2 # In Python 2 this would be integer division
print(f"Score ratio: {ratio}")

The code correctly calculates an average with the / operator. It also highlights a legacy issue from Python 2, where the same operator would perform integer division, truncating the result. See how to handle this correctly.

# Calculate average score
num_students = 10
total_score = 87
average = total_score / num_students # In Python 3, / always returns float
print(f"Class average: {average}")

# For integer division, use // operator explicitly
score1 = 7
score2 = 2
ratio = score1 / score2 # Float division: 3.5
integer_ratio = score1 // score2 # Integer division: 3
print(f"Score ratio: {ratio}, Integer ratio: {integer_ratio}")

In Python 3, the / operator always performs float division, so total_score / num_students correctly yields a decimal. This change fixed the accidental truncation that could happen in older versions. If you intentionally want to discard the remainder and get a whole number, you must use the floor division operator, //. Always be mindful of which operator you're using in mathematical calculations to prevent subtle bugs in your logic.

Fixing TypeError when concatenating strings and numbers

Python's strong typing means it won't automatically convert a number to a string when you use the + operator. Attempting to combine them directly results in a TypeError because Python can't decide whether to add or concatenate. See what happens.

# User information
name = "Alice"
age = 30
message = "Hello, " + name + "! You are " + age + " years old."
print(message)

The code fails because it tries using the + operator on incompatible types—a string and the integer age. This ambiguity causes a TypeError. The corrected version below shows how to handle this properly.

# User information
name = "Alice"
age = 30
message = "Hello, " + name + "! You are " + str(age) + " years old."
print(message)

# Alternative using f-strings (more readable)
message = f"Hello, {name}! You are {age} years old."
print(message)

The fix is to explicitly convert the number to a string before combining it with other text. The first solution uses the str() function, as in str(age), to handle the conversion manually. This removes the ambiguity for the + operator.

A more modern and readable approach is using an f-string. It automatically handles the type conversion inside the curly braces, resulting in cleaner code that's less prone to this kind of TypeError. This is especially useful when constructing messages from multiple variables.

Handling ValueError in type conversions

A ValueError occurs when you use a function like int() to convert a string to a number, but the string contains non-numeric text. This is a classic problem with user input. The code below shows what happens if someone enters "abc".

# Convert user input to int
user_input = input("Enter a number: ") # What if user enters "abc"?
number = int(user_input)
result = number * 2
print(f"Double your number: {result}")

The program will crash if the user provides non-numeric input. The int() function can't parse text like "abc", which raises a ValueError and stops execution. The corrected code below shows how to prevent this.

# Convert user input to int with error handling
user_input = input("Enter a number: ")
try:
number = int(user_input)
result = number * 2
print(f"Double your number: {result}")
except ValueError:
print("Error: Please enter a valid number")

The corrected code prevents crashes by wrapping the conversion in a try-except block. It attempts to run the risky code inside the try statement. If the int() function fails because the input isn't a number, it triggers a ValueError, and the except block runs instead. This lets you handle the error gracefully—like showing a message—which is crucial when dealing with unpredictable user input.

Real-world applications

With a grasp on fixing common errors, you can now use primitive types to build practical tools like temperature and currency converters.

Building a temperature converter with float types

The float type is perfect for calculations that require decimal precision, like converting temperatures, and it's essential when you need to turn a string input into a number for the formula.

celsius = 25.0
fahrenheit = (celsius * 9/5) + 32
print(f"{celsius}°C = {fahrenheit}°F")

temp_str = "100"
temp_c = float(temp_str)
temp_f = (temp_c * 9/5) + 32
print(f"Converted: {temp_str}°C = {temp_f}°F")

This code shows two ways to perform a Celsius to Fahrenheit conversion. The first example uses a predefined float value, celsius = 25.0, in a standard mathematical formula. The second example tackles a more practical scenario where the temperature is initially a string, like "100".

• It uses the float() function to explicitly convert the string into a number before the calculation.
• Both conversions use f-strings to embed the results directly into the output for clear, readable messages.

Creating a currency converter with float and str types

This same combination of float for arithmetic and str for input is essential for a currency converter, where you'll often need to process numerical data that starts as text.

rates = {"USD": 1.0, "EUR": 0.85, "GBP": 0.75}
amount = 100.0 # EUR
usd_amount = amount / rates["EUR"] # Convert to USD
gbp_amount = usd_amount * rates["GBP"] # Convert to GBP
print(f"{amount} EUR = {round(gbp_amount, 2)} GBP")

amount_str = "50.5" # USD as string
amount_float = float(amount_str)
eur_result = amount_float * rates["EUR"]
print(f"{amount_str} USD = {round(eur_result, 2)} EUR")

This code builds a currency converter by storing exchange rates in a rates dictionary, using USD as a base currency. This structure simplifies multi-step conversions, like the first example that converts EUR to GBP by going through USD first. The second example shows how to handle a numeric value stored as a string by converting it with float() before performing calculations. In both cases, the round() function formats the final output to two decimal places, which is standard practice for currency.

Get started with Replit

Now, turn these concepts into a working tool. Describe what you want to Replit Agent, like “Build a loan calculator using the Decimal type” or “Create a tool to convert temperatures from a CSV file.”

The Agent writes the code, tests for common errors, and helps you deploy the final app. Start building with Replit.