🔢 Data Handling

Every program you will ever write does just ONE thing at its heart — it takes data, works on it, and produces a result! 📥⚙️📤 But how does Python know that 25 is a number and "25" is text? Why does 7 / 2 give 3.5 but 7 // 2 gives 3? Why can you change a list but NOT a string? This chapter answers these BIG questions: What types of data can Python store? What are mutable and immutable types? How do operators and expressions work? How does Python convert one type into another? Let's handle some data! 🐍🔢

6.1 🏁 Introduction

Data Handling means how a programming language stores, identifies, and processes different kinds of data. In Python, every value you use — a number, a name, a list of marks — has a data type, and you work on it using operators to form expressions.

graph LR
    DATA["📦 Data\n(values like 25,\n'Riya', 3.14)"]
    TYPE["🏷️ Data Type\n(int, str, float...)"]
    OPS["➕ Operators\n(+, -, ==, and...)"]
    EXPR["🧮 Expression\n(a + b * 2)"]
    RESULT["✅ Result"]

    DATA --> TYPE --> OPS --> EXPR --> RESULT

    style TYPE fill:#2196F3,color:#fff
    style OPS fill:#FF9800,color:#fff
    style RESULT fill:#4CAF50,color:#fff

Think of it this way: Data types are like containers in a kitchen — you store milk in a bottle, rice in a jar, and eggs in a tray. Each container is designed for ONE kind of item. Python similarly uses the RIGHT "container" (data type) for each kind of value!

6.2 🏷️ Data Types

A data type tells Python what kind of value a variable holds and what operations can be performed on it. You can check the type of any value using the type() function.

>>> type(25)
<class 'int'>
>>> type(3.14)
<class 'float'>
>>> type("Hello")
<class 'str'>
>>> type(True)
<class 'bool'>

Python's Core Data Types:

graph TD
    DT["🏷️ PYTHON DATA TYPES"]
    NUM["🔢 Numbers"]
    SEQ["📚 Sequences"]
    MAP["🗂️ Mappings"]
    NONE["🚫 None"]

    INT["int\n(Integer)"]
    BOOL["bool\n(Boolean)"]
    FLOAT["float\n(Floating point)"]
    COMP["complex\n(Complex numbers)"]

    STR["str\n(String)"]
    LIST["list"]
    TUP["tuple"]

    DICT["dict\n(Dictionary)"]

    DT --> NUM
    DT --> SEQ
    DT --> MAP
    DT --> NONE
    NUM --> INT
    NUM --> BOOL
    NUM --> FLOAT
    NUM --> COMP
    SEQ --> STR
    SEQ --> LIST
    SEQ --> TUP
    MAP --> DICT

    style NUM fill:#2196F3,color:#fff
    style SEQ fill:#FF9800,color:#fff
    style MAP fill:#4CAF50,color:#fff
    style NONE fill:#9E9E9E,color:#fff

6.2.1 Numbers 🔢

Python has four numeric types:

1. Integers (int) — Python integers have unlimited precision: they can be as large as your computer's memory allows!

>>> big = 2 ** 100
>>> print(big)
1267650600228229401496703205376

2. Booleans (bool) — have only two values, True and False (capital T and F). Internally, True behaves like 1 and False like 0.

>>> True + True
2
>>> False * 10
0
>>> bool(0), bool(15), bool("")
(False, True, False)

3. Floating Point Numbers (float) — can be written in two forms:

4. Complex Numbers (complex) — written as a + bj, where a is the real part and b is the imaginary part. Python uses j (not i) for the imaginary unit.

>>> z = 3 + 4j
>>> z.real
3.0
>>> z.imag
4.0

6.2.2 Strings (str) 🔤

A string is a sequence of characters enclosed in single quotes (' '), double quotes (" "), or triple quotes (''' ''' / """ """) for multi-line text.

name = 'Riya'
school = "Delhi Public School"
address = """House No. 12,
Park Street,
Kolkata"""

Each character in a string has a position called an index. Python supports two-way indexing:

  String :    P     Y     T     H     O     N
 Forward :    0     1     2     3     4     5
Backward :   -6    -5    -4    -3    -2    -1

>>> word = "PYTHON"
>>> word[0]
'P'
>>> word[-1]
'N'
>>> len(word)
6

6.2.3 Lists and Tuples 📚

Both lists and tuples store an ordered collection of values (which can be of different types).

marks = [85, 90, 78]       # list
marks[0] = 95              # ✅ allowed — lists can be changed
print(marks)               # [95, 90, 78]

days = ("Mon", "Tue", "Wed")   # tuple
# days[0] = "Sun"          # ❌ TypeError — tuples cannot be changed

6.2.4 Dictionaries (dict) 🗂️

A dictionary is an unordered-by-position collection of key : value pairs enclosed in curly braces { }. You access values using their keys, not index numbers.

student = {"name": "Aman", "class": 11, "marks": 92}
print(student["name"])     # Aman
student["marks"] = 95      # values can be changed

Analogy: A dictionary is exactly like a real dictionary — you look up a word (key) to find its meaning (value). You never search a dictionary by "page number 237"!

6.2.5 The None Type 🚫

None is a special value that means "nothing" or "no value". Its type is NoneType.

>>> result = None
>>> type(result)
<class 'NoneType'>

6.3 🔄 Mutable and Immutable Types

This is one of the MOST important concepts of this chapter! Python data types are divided into two groups based on whether their value can be changed in place.

graph TD
    TYPES["🔄 PYTHON TYPES"]
    IMM["🔒 IMMUTABLE\n(cannot be changed in place)"]
    MUT["🔓 MUTABLE\n(can be changed in place)"]

    I1["int, float, complex, bool"]
    I2["str (strings)"]
    I3["tuple"]

    M1["list"]
    M2["dict (dictionary)"]
    M3["set"]

    TYPES --> IMM
    TYPES --> MUT
    IMM --> I1
    IMM --> I2
    IMM --> I3
    MUT --> M1
    MUT --> M2
    MUT --> M3

    style IMM fill:#F44336,color:#fff
    style MUT fill:#4CAF50,color:#fff

6.3.1 Every Object Has Three Things 🔍

Every value (object) in Python has:

6.3.2 Immutable Types 🔒

For immutable types, the value stored at a memory location can never be changed. When you "change" the variable, Python actually creates a NEW object at a new memory location and makes the variable point to it.

>>> a = 10
>>> id(a)
140714234567120        # (your number will be different)
>>> a = a + 5
>>> id(a)
140714234567280        # a DIFFERENT address! a new object 15 was created

graph LR
    A1["a"]
    V10["🔒 10\n(old object)"]
    V15["🔒 15\n(new object)"]

    A1 -.->|"before"| V10
    A1 -->|"after a = a + 5"| V15

    style V10 fill:#9E9E9E,color:#fff
    style V15 fill:#2196F3,color:#fff

Analogy: Immutable objects are like a printed book. You can't erase a word in it — to "change" it, a NEW edition must be printed, and you start reading the new one. The old book still exists (until it's thrown away)!

6.3.3 Mutable Types 🔓

For mutable types, the value can be changed in place — the memory address (id) stays the SAME.

>>> marks = [70, 80, 90]
>>> id(marks)
2034567891200
>>> marks[0] = 100
>>> id(marks)
2034567891200          # SAME address — the list was changed in place
>>> marks
[100, 80, 90]

Analogy: Mutable objects are like a whiteboard — you can erase and rewrite on the SAME board as many times as you like!

6.4 ➕ Operators

Operators are symbols that perform operations on values. The values on which they operate are called operands.

        a    +    b
        ↑    ↑    ↑
  operand operator operand

graph TD
    OPS["➕ PYTHON OPERATORS"]
    AR["🔢 Arithmetic\n+ - * / // % **"]
    REL["⚖️ Relational\n< > <= >= == !="]
    LOG["🧠 Logical\nand or not"]
    ASG["📝 Assignment\n= += -= *= ..."]
    ID["🆔 Identity\nis, is not"]
    MEM["📦 Membership\nin, not in"]

    OPS --> AR
    OPS --> REL
    OPS --> LOG
    OPS --> ASG
    OPS --> ID
    OPS --> MEM

    style AR fill:#2196F3,color:#fff
    style REL fill:#FF9800,color:#fff
    style LOG fill:#9C27B0,color:#fff
    style ASG fill:#4CAF50,color:#fff
    style ID fill:#F44336,color:#fff
    style MEM fill:#795548,color:#fff

6.4.1 Arithmetic Operators 🔢

Unary operators: + and - can also work on a single operand: -a (negation), +a.

The three division operators — the most tested topic!

print(10 / 2)      # 5.0   (float, not 5!)
print(17 // 5)     # 3
print(17 % 5)      # 2
print(17.0 // 5)   # 3.0   (float operand → float result)
print(-17 // 5)    # -4    (rounded DOWN towards minus infinity!)
print(-17 % 5)     # 3

Exponentiation is Right-Associative:

print(2 ** 3 ** 2)    # 512 → evaluated as 2 ** (3 ** 2) = 2 ** 9
print((2 ** 3) ** 2)  # 64
print(-2 ** 2)        # -4  → evaluated as -(2 ** 2)

Arithmetic operators on strings:

print("Hi" + "There")   # HiThere   (concatenation)
print("Ha" * 3)          # HaHaHa    (replication)
# print("Age" + 16)      # ❌ TypeError: can only concatenate str (not "int") to str

6.4.2 Relational (Comparison) Operators ⚖️

Relational operators compare two values and always return a Boolean result (True or False).

print("apple" < "banana")   # True  (compared letter by letter using Unicode values)
print("Zoo" < "apple")      # True  (uppercase letters come BEFORE lowercase: 'Z' = 90, 'a' = 97)
print(1 < 5 < 10)           # True  (chained comparison = 1 < 5 and 5 < 10)

6.4.3 Identity Operators 🆔

Identity operators check whether two variables refer to the SAME object in memory (same id()), not just equal values.

a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b)   # True   → same VALUE
print(a is b)   # False  → different OBJECTS in memory
print(a is c)   # True   → c points to the SAME object as a

graph LR
    A["a"]
    C["c"]
    B["b"]
    L1["📋 [1, 2, 3]\n(object 1)"]
    L2["📋 [1, 2, 3]\n(object 2)"]

    A --> L1
    C --> L1
    B --> L2

    style L1 fill:#2196F3,color:#fff
    style L2 fill:#FF9800,color:#fff

6.4.4 Logical Operators 🧠

Logical operators combine conditions: and, or, not.

Truth Value Testing — In Python, every value is either "truthy" or "falsy":

and / or return one of the OPERANDS, not always True/False:

print(0 or 7)         # 7     → first operand is falsy, so returns the second
print(5 or 7)         # 5     → first operand is truthy, so returns it (second not checked)
print(5 and 7)        # 7     → first is truthy, so returns the second
print(0 and 7)        # 0     → first is falsy, so returns it (second not checked)
print(not 5)          # False → not ALWAYS returns True or False
print("" or "Empty")  # Empty

6.4.5 Assignment and Augmented Assignment Operators 📝

The = operator assigns a value to a variable. Augmented assignment operators combine an arithmetic operation with assignment.

x = 10
x += 5      # x is now 15
x *= 2      # x is now 30
x //= 4     # x is now 7
print(x)    # 7

6.4.6 Membership Operators 📦

Membership operators check whether a value is present in a sequence (string, list, tuple, dictionary keys).

print("a" in "Python")          # False
print("th" in "Python")         # True
print(3 in [1, 2, 3])           # True
print(5 not in (1, 2, 3))       # True
print("name" in {"name": "Aman"})  # True  → checks KEYS of a dictionary

6.4.7 Operator Precedence and Associativity 🪜

When an expression has multiple operators, Python follows a fixed order called precedence (just like BODMAS in maths!).

graph TD
    P1["1️⃣ ( )  Parentheses — HIGHEST"]
    P2["2️⃣ **  Exponentiation"]
    P3["3️⃣ +x, -x  Unary plus / minus"]
    P4["4️⃣ *, /, //, %"]
    P5["5️⃣ +, -  (Binary)"]
    P6["6️⃣ <, <=, >, >=, ==, !=,\nis, is not, in, not in"]
    P7["7️⃣ not"]
    P8["8️⃣ and"]
    P9["9️⃣ or — LOWEST"]

    P1 --> P2 --> P3 --> P4 --> P5 --> P6 --> P7 --> P8 --> P9

    style P1 fill:#F44336,color:#fff
    style P2 fill:#FF9800,color:#fff
    style P9 fill:#4CAF50,color:#fff

Associativity decides the order when operators of the same precedence appear together:

• Almost all operators are left-to-right associative: 20 / 4 * 2 = (20 / 4) * 2 = 10.0
• `is right-to-left** associative:2 ** 3 ** 2=2 ** 9=512`

Example — Evaluate 12 + 3 * 2 ** 2 // 5 - 1:

12 + 3 * 2 ** 2 // 5 - 1
= 12 + 3 * 4 // 5 - 1       (** first)
= 12 + 12 // 5 - 1          (* and // left to right: 3 * 4 = 12)
= 12 + 2 - 1                (12 // 5 = 2)
= 13                        (+ and - left to right)

6.5 🧮 Expressions

An expression is a valid combination of operators, literals and variables that Python evaluates to produce a value.

6.5.1 Type Conversion 🔁

When an expression has values of different types, Python must convert them to a common type. There are two ways this happens:

graph TD
    TC["🔁 TYPE CONVERSION"]
    IMP["🤖 Implicit Conversion\n(Automatic — done by Python)\nAlso called Coercion"]
    EXP["🧑‍💻 Explicit Conversion\n(Done by the programmer)\nAlso called Type Casting"]

    TC --> IMP
    TC --> EXP

    style IMP fill:#2196F3,color:#fff
    style EXP fill:#FF9800,color:#fff

1. Implicit Type Conversion (Coercion) — Python automatically converts the "smaller" type to the "bigger" type so that no data is lost:

bool  →  int  →  float  →  complex

a = 5          # int
b = 2.5        # float
c = a + b      # int is automatically converted to float
print(c, type(c))    # 7.5 <class 'float'>
print(True + 3.5)    # 4.5  (True → 1 → 1.0)

2. Explicit Type Conversion (Type Casting) — the programmer converts a value using type-conversion functions:

age = input("Enter your age: ")     # input() ALWAYS returns a string
print(type(age))                    # <class 'str'>
age = int(age)                      # explicit conversion to int
print(age + 1)

6.5.2 Working with the math Module 📐

Python's math module provides ready-made mathematical functions. You must import it first.

import math
print(math.sqrt(49))      # 7.0
print(math.pow(2, 5))     # 32.0
print(math.ceil(4.2))     # 5
print(math.floor(4.8))    # 4
print(math.fabs(-7.5))    # 7.5
print(math.pi)            # 3.141592653589793

You'll study the math, random and statistics modules in detail in the Python Modules chapter.

Writing maths formulas as Python expressions:

6.6 🐞 Errors in a Program

While writing programs, you WILL make mistakes — that's normal! Errors (also called bugs) are of three main types, and removing them is called debugging.

graph TD
    ERR["🐞 ERRORS"]
    SYN["✍️ Syntax Error\n(Compile-time)\nRules of the language broken"]
    RUN["💥 Runtime Error\n(Exception)\nProgram crashes while running"]
    LOG["🤔 Logical Error\nProgram runs but gives\nWRONG output"]

    ERR --> SYN
    ERR --> RUN
    ERR --> LOG

    style SYN fill:#FF9800,color:#fff
    style RUN fill:#F44336,color:#fff
    style LOG fill:#9C27B0,color:#fff

Common Runtime Errors (Exceptions):

⚠️ Common Errors and Misconceptions

🔑 Quick Revision — Exam Ready!

Data Types — One-Line Summary:

• int → Whole numbers, unlimited size (25, -7)
• bool → True / False (sub-type of int: True = 1, False = 0)
• float → Decimal numbers, ~15 digit precision (3.14, 2.5E3)
• complex → a + bj; .real and .imag return floats
• str → Text in quotes; two-way indexing (0 to n-1, -1 to -n)
• list [ ] → Ordered, mutable
• tuple ( ) → Ordered, immutable
• dict {key: value} → Key-value pairs, mutable
• None → Absence of a value

Mutable vs Immutable:

Division Operators:

Precedence (high → low): () → ** → unary + - → * / // % → + - → relational / is / in → not → and → or

Type Conversion:

• Implicit → automatic: bool → int → float → complex
• Explicit → by programmer: int(), float(), str(), bool()

🎯 Sample Board Exam Questions

Q1: Very Short Answer [1 mark each]

a) What will be the output of print(type(10 / 2))? → <class 'float'>

b) Name any two immutable data types in Python. → int and str (also float, tuple, bool, complex)

c) What is the output of print(15 % 4)? → 3

d) Which function is used to get the memory address (identity) of an object? → id()

e) What is the output of print(2 ** 2 ** 3)? → 256 (evaluated as 2 ** 8)

f) What will bool("") return? → False

Q2: Short Answer [2 marks]

Q: What are mutable and immutable data types? Give two examples of each.

Mutable data types are those whose values can be changed in place, without changing their memory address (id). Examples: list, dictionary. Immutable data types are those whose values cannot be changed in place; any change creates a new object at a new memory address. Examples: int, string, tuple.

Q3: Short Answer [2 marks]

Q: Evaluate the following expressions:

a) 20 // 3 + 2 ** 3 % 5 b) not 5 > 3 or 4 < 2

Answer:

a) 20 // 3 + 2 ** 3 % 5
 = 20 // 3 + 8 % 5       (** first)
 = 6 + 3                 (// and % left to right)
 = 9

b) not 5 > 3 or 4 < 2
 = not True or False     (relational first)
 = False or False        (not before or)
 = False

Q4: Output Based [3 marks]

Q: Write the output of the following code:

a = 17
b = 5
print(a / b, a // b, a % b)
a, b = b, a
print(a ** 2 - b)
x = 0 or "Python"
print(x)
print(int(7.99) + float("2"))

Answer:

3.4 3 2
8
Python
9.0

Q5: Short Answer [2 marks]

Q: Differentiate between == and is operators with an example.

The == operator compares the values of two objects, while the is operator checks whether two variables refer to the same object in memory.

L1 = [1, 2]
L2 = [1, 2]
print(L1 == L2)   # True  → values are equal
print(L1 is L2)   # False → two different objects

✏️ Practice Problems

1. Name the four numeric data types in Python and give one example of each.

2. Explain two-way indexing in strings using the string "SCHOOL". What are the forward and backward indices of the letter 'H'?

3. Explain, with the help of id(), why integers are called immutable but lists are called mutable.

4. Predict the output:

   print(-22 // 5, -22 % 5)
   print(22 / 5, 22 // 5.0)
   print(3 * "ab" + "c")

5. Evaluate: (a) 5 + 3 * 2 ** 2 - 8 / 4 (b) 10 > 5 and 3 > 4 or not 7 == 7

6. What will print(0 and 5, 3 or 0, not 0) display? Explain each result.

7. Write the Python expressions for: (a) (a + b)² (b) √(x² + y²) (c) ½ × base × height

8. Find the error(s) in the following code and rewrite it correctly:

   num = input("Enter a number")
   square = num ** 2
   Print("Square is" + square)

9. Write a program that accepts the radius of a circle and prints its area and circumference using math.pi.

10. Identify the type of error (syntax, runtime or logical) in each case: (a) print("Total" , 5 / 0) (b) if x == 5 print(x) (c) Calculating the average of three numbers as a + b + c / 3