Python Data Types

A data type describes the kind of value an object represents.

For example, a person's age is normally represented by an integer, while their name is represented by a string.

name = "Ali"
age = 25
height = 5.9
is_student = True

print(type(name))
print(type(age))
print(type(height))
print(type(is_student))

<class 'str'>
<class 'int'>
<class 'float'>
<class 'bool'>

Data types determine what kind of operations can be performed on a value.

For example, numbers can be mathematically added, while strings can be joined together.

number_result = 10 + 20

text_result = "Hello " + "Python"

print(number_result)
print(text_result)

30
Hello Python

Python provides the built-in type() function for checking the type of an object.

value = 100

print(type(value))

value = "Python"

print(type(value))

<class 'int'>
<class 'str'>

Python provides three built-in numeric types: int, float and complex.

whole_number = 100
decimal_number = 12.5
complex_number = 3 + 4j

print(type(whole_number))
print(type(decimal_number))
print(type(complex_number))

<class 'int'>
<class 'float'>
<class 'complex'>

An integer, represented by int, is a whole number without a decimal component.

Integers can be positive, negative or zero.

age = 25
temperature = -5
score = 0

print(age)
print(temperature)
print(score)

25
-5
0

Python integers can represent arbitrarily large whole numbers, subject to available memory.

A float represents a number with a decimal component.

price = 99.99
temperature = -2.5
rating = 4.8

print(type(price))
print(type(temperature))
print(type(rating))

<class 'float'>
<class 'float'>
<class 'float'>

Python also supports complex numbers. A complex number contains a real part and an imaginary part.

Python uses j to represent the imaginary component.

number = 3 + 4j

print(number)
print(number.real)
print(number.imag)

(3+4j)
3.0
4.0

Complex numbers are commonly used in scientific, engineering and mathematical applications.

A string, represented by str, is a sequence of characters used to represent text.

Strings can be written using single quotes, double quotes or triple quotes.

name = "Ali"
city = 'Multan'
message = """Welcome to PyLearn"""

print(name)
print(city)
print(message)

Ali
Multan
Welcome to PyLearn

Strings are immutable, which means the existing string object cannot be changed in place. Operations that appear to modify a string generally create a new string.

The Boolean type, written as bool, has two values: True and False.

is_logged_in = True
has_permission = False

print(is_logged_in)
print(has_permission)

print(type(is_logged_in))

True
False
<class 'bool'>

Boolean values are especially important when working with conditions and decision-making.

A list is an ordered collection that can contain multiple values.

Lists are created using square brackets [].

fruits = ["apple", "banana", "orange"]

print(fruits)
print(fruits[0])

['apple', 'banana', 'orange']
apple

Lists are mutable, meaning their contents can be changed after creation.

fruits = ["apple", "banana"]

fruits.append("orange")

print(fruits)

['apple', 'banana', 'orange']

A tuple is an ordered collection that is generally used for values that should not be changed.

Tuples are commonly written using parentheses.

coordinates = (10, 20)

print(coordinates)
print(coordinates[0])

(10, 20)
10

Tuples are immutable, so their existing elements cannot be changed after the tuple has been created.

A set is an unordered collection of unique elements.

Sets are useful when you need to remove duplicates or perform mathematical set operations.

numbers = {1, 2, 3, 3, 4}

print(numbers)

The duplicate 3 is represented only once in the set.

A dictionary, represented by dict, stores data as key-value pairs.

student = {
    "name": "Ali",
    "age": 21,
    "city": "Multan"
}

print(student["name"])
print(student["age"])

Ali
21

Dictionaries are extremely useful for representing structured information.

student = {
    "name": "Ali",
    "age": 21
}

student["age"] = 22

print(student)

{'name': 'Ali', 'age': 22}

None represents the absence of a value. Its type is NoneType.

result = None

print(result)
print(type(result))

None
<class 'NoneType'>

None is often used to indicate that a value has not been provided yet or that a function intentionally has no meaningful return value.

One important concept in Python is whether an object is mutable or immutable.

Mutable Objects

Mutable objects can be changed after they are created.

Common mutable types include:

• Lists
• Dictionaries
• Sets

Immutable Objects

Immutable objects cannot be changed after they are created.

Common immutable types include:

• Integers
• Floats
• Booleans
• Strings
• Tuples

numbers = [1, 2, 3]

numbers.append(4)

print(numbers)

[1, 2, 3, 4]

text = "Python"

text = text + " Programming"

print(text)

Python Programming

In the string example, Python creates a new string rather than changing the original string object in place.

The type() function is especially useful when learning Python and debugging unexpected values.

values = [
    42,
    3.14,
    "Python",
    True,
    [1, 2, 3],
    (1, 2),
    {1, 2},
    {"name": "Ali"},
    None
]

for value in values:
    print(type(value))

<class 'int'>
<class 'float'>
<class 'str'>
<class 'bool'>
<class 'list'>
<class 'tuple'>
<class 'set'>
<class 'dict'>
<class 'NoneType'>

1. Confusing Numbers and Strings

age = 25
age_text = "25"

print(type(age))
print(type(age_text))

Although both values visually contain 25, one is an integer and the other is a string.

2. Using the Wrong Collection

Choose a collection based on what your program needs. For example, use a list when order and duplicates matter, and a set when uniqueness is important.

3. Confusing None With False

None means the absence of a value. False is a Boolean value representing logical falsity. They are different objects and should not be treated as interchangeable.

4. Expecting Strings to Change In Place

Strings are immutable. String operations produce new string values rather than modifying the existing string object.

Python provides several built-in data types for representing different kinds of information.

• int represents whole numbers.
• float represents floating-point numbers.
• complex represents complex numbers.
• str represents text.
• bool represents True or False.
• list stores an ordered, mutable collection.
• tuple stores an ordered, immutable collection.
• set stores unique elements.
• dict stores key-value pairs.
• None represents the absence of a value.
• type() can be used to inspect an object's type.