Beginner

24 min read

Python Basics — Variables, Data Types, Operators & I/O

Master Python Basics for CBSE Class 11 Informatics Practices. Covers Python features and execution modes, variables and identifier rules, int float str bool data types with type() function, arithmetic comparison and logical operators with precedence, print() with sep end and f-strings, input() type conversion int float str bool, common output prediction traps with verified board-level practice questions.

New

Python is the core language of Informatics Practices and the skill you will use throughout Class 11 and 12 — from writing basic programs to handling data with Pandas and querying databases. This note covers everything you need to get started: how Python stores data (variables and data types), how it performs calculations (operators), how it communicates with the user (input and output), and how to convert between types. These fundamentals underpin every program you will write. For CBSE IP board exams, Python basics appear as MCQs, output-prediction questions, and short program-writing questions — making this a consistently scoring section.

1. Python — Introduction and Features

Python is a high-level, interpreted, general-purpose programming language created by Guido van Rossum and first released in 1991. It emphasises code readability and simplicity.

Key Features of Python

Feature	Meaning
Interpreted	Executed line by line — no separate compilation step needed
Dynamically typed	No need to declare variable type — Python infers it automatically
High-level	Close to human language — readable and easy to write
Open source & free	Free to use, modify and distribute
Platform independent	Runs on Windows, Linux, macOS — write once, run anywhere
Large standard library	Built-in modules for maths, file I/O, data handling (NumPy, Pandas, Matplotlib)

Python Execution Modes

Mode	How it works	When to use
Interactive Mode	Type one statement at a time in Python shell; instant output after each line	Testing small expressions, quick calculations
Script Mode	Write complete program in a `.py` file; run all at once	Writing full programs, saving work

2. Variables and Assignment

A variable is a named memory location that stores a value. In Python, a variable is created the moment you assign a value to it — no declaration needed.

# Creating variables
name = 'Priya'        # str
age = 16              # int
marks = 92.5          # float
passed = True         # bool

# Multiple assignment
a = b = c = 0         # all three get value 0
x, y, z = 10, 20, 30  # simultaneous assignment

Rules for Variable Names (Identifiers)

Must begin with a letter (a–z, A–Z) or underscore (_) — not a digit.
Can contain letters, digits, and underscores — no spaces or special characters.
Case-sensitive: marks, Marks and MARKS are three different variables.
Cannot be a Python keyword (reserved word) like if, for, while, True, None.

Valid	Invalid	Reason Invalid
`student_name`	`1name`	Starts with a digit
`_total`	`my name`	Contains a space
`marks2`	`for`	Python keyword
`totalMarks`	`my-var`	Contains hyphen (–)

3. Data Types in Python

Python has several built-in data types. The four core types for IP are:

Data Type	Keyword	Description	Examples
Integer	`int`	Whole numbers (positive, negative, zero) — no decimal point	`10, -5, 0, 1000`
Float	`float`	Numbers with a decimal point (real numbers)	`3.14, -2.5, 0.0, 1.0`
String	`str`	Sequence of characters enclosed in quotes (single, double, or triple)	`'Priya', "hello", '123'`
Boolean	`bool`	Logical values — only two possible values	`True, False`

# Checking data type using type()
print(type(10))       # <class 'int'>
print(type(3.14))     # <class 'float'>
print(type('hello'))  # <class 'str'>
print(type(True))    # <class 'bool'>

Important Note: Dynamic Typing

In Python, a variable's type is determined by the value assigned — and can change:

x = 10        # x is int
x = 'hello'   # now x is str — same variable, different type
x = 3.14      # now x is float

4. Operators in Python

Arithmetic Operators

Operator	Operation	Example	Result
`+`	Addition	`10 + 3`	`13`
`-`	Subtraction	`10 - 3`	`7`
`*`	Multiplication	`10 * 3`	`30`
`/`	Division (always float)	`10 / 3`	`3.3333...`
`//`	Floor Division (integer quotient)	`10 // 3`	`3`
`%`	Modulo (remainder)	`10 % 3`	`1`
`**`	Exponentiation (power)	`2 ** 8`	`256`

Comparison (Relational) Operators

Return True or False.

Operator	Meaning	Example	Result
`==`	Equal to	`5 == 5`	`True`
`!=`	Not equal to	`5 != 3`	`True`
`>`	Greater than	`7 > 3`	`True`
`<`	Less than	`2 < 5`	`True`
`>=`	Greater than or equal	`10 >= 10`	`True`
`<=`	Less than or equal	`3 <= 5`	`True`

Logical Operators

Combine multiple conditions — also return True or False.

Operator	Rule	Example	Result
`and`	True only if BOTH conditions are True	`True and False`	`False`
`or`	True if AT LEAST ONE condition is True	`True or False`	`True`
`not`	Reverses the boolean value	`not True`	`False`

Operator Precedence (BODMAS for Python)

From highest to lowest priority:

** > * / // % > + - > == != > < >= <= > not > and > or

print(2 + 3 * 4)        # 14  (not 20 — * before +)
print(2 ** 3 + 1)       # 9   (** first: 8 + 1)
print(10 % 3 + 2)       # 3   (% first: 1 + 2)
print((2 + 3) * 4)      # 20  (parentheses override)

5. Input and Output

Output — `print()`

# Basic print
print('Hello, World!')          # Hello, World!
print('Marks:', 95)              # Marks: 95

# sep and end parameters
print(1, 2, 3, sep='-')          # 1-2-3
print('Hello', end=' ')
print('World')                    # Hello World (on same line)

# f-string (formatted string literal)
name = 'Aryan'
marks = 95
print(f'Student: {name} Marks: {marks}')   # Student: Aryan Marks: 95

Input — `input()`

input() always returns a string — you must convert it to the required type.

# input() always returns str
name = input('Enter your name: ')     # str
age  = int(input('Enter age: '))     # convert to int
gpa  = float(input('Enter GPA: '))   # convert to float

# Common mistake — forgetting to convert
x = input('Enter number: ')         # x = '5' (string!)
print(x + 3)                          # ERROR: can't add str and int
print(int(x) + 3)                    # 8 (correct)

6. Type Conversion

Python allows converting values from one data type to another using built-in functions:

Function	Converts to	Example	Output
`int()`	Integer	`int('42')`, `int(3.9)`	`42`, `3` (truncates)
`float()`	Float	`float('3.14')`, `float(5)`	`3.14`, `5.0`
`str()`	String	`str(100)`, `str(3.14)`	`'100'`, `'3.14'`
`bool()`	Boolean	`bool(0)`, `bool(1)`, `bool('')`, `bool('hi')`	`False`, `True`, `False`, `True`

Key rule for bool(): 0, 0.0, '' (empty string), None, and empty collections → False. Everything else → True.

Key rule for int(float): int(3.9) gives 3 — it truncates (removes decimal part), it does NOT round.

7. Comments and Indentation

# This is a single-line comment — ignored by Python

"""
This is a multi-line comment (docstring).
Used to document functions and programs.
"""

# Indentation is MANDATORY in Python (4 spaces or 1 tab)
if 10 > 5:
    print('Yes')    # indented block
print('Done')     # back to main level

Unlike most languages, Python uses indentation (whitespace) to define code blocks — not curly braces {}. Inconsistent indentation causes an IndentationError.

Output Prediction — Quick Reference

Expression	Output	Why
`print(10 / 2)`	`5.0`	`/` always returns float
`print(10 // 3)`	`3`	Floor division — integer quotient
`print(int(3.9))`	`3`	Truncates, does NOT round
`print(type(5/2))`	`<class 'float'>`	`/` always gives float
`print('Hi' * 3)`	`HiHiHi`	String repetition with `*`
`print('5' + '3')`	`53`	String concatenation, NOT addition
`print(bool(0), bool(''), bool(1))`	`False False True`	0 and empty string are falsy
`print(2 ** 10)`	`1024`	Exponentiation: 2¹⁰
`print(1, 2, 3, sep='*')`	`123`	`sep` replaces the default space

Board Exam Power Tips — Avoid These Common Mistakes

/ always returns a float, even for whole-number results. 10 / 2 gives 5.0, NOT 5. Use // if you need an integer result. This is a very common output-prediction trap.
input() always returns a string. x = input() — even if the user types 42, Python stores it as '42' (string). You must wrap with int() or float() to do arithmetic. Forgetting this causes TypeError.
int(3.9) gives 3, NOT 4. int() truncates the decimal — it does not round. Use round(3.9) if you want rounding.
'5' + '3' gives '53', not 8. The + operator on strings is concatenation. Adding a string and an integer directly ('5' + 3) causes a TypeError — you must convert first.
Variable names are case-sensitive. Marks and marks are completely different variables. Board questions sometimes test this with tricky code where a variable is defined with one case and used with another.
Python has no ++ or -- operators (unlike C/Java). Use x += 1 or x -= 1 instead. Writing x++ in Python causes a SyntaxError.
Indentation is NOT optional in Python. Every block (after if, for, def) must be consistently indented. Mixing spaces and tabs causes IndentationError. CBSE practical exams check for proper indentation.

Practice Questions (CBSE Board Level)

Q1 (2 marks): Write the output of the following Python code:

a = 15
b = 4
print(a // b)
print(a % b)
print(a ** b)
print(type(a / b))

Output:

3
3
50625
<class 'float'>

Explanation:
15 // 4 = 3 (floor division: discards the fractional part).
15 % 4 = 3 (modulo: gives the remainder, 15 = 4 × 3 + 3).
15 ** 4 = 50625 (exponentiation: 15 to the power of 4).
a / b performs true division, which always returns a float in Python 3. Therefore, the type is float.

Q2 (2 marks): Write the output of the following code:

x = 10
y = 3
print(x // y)
print(x % y)
print(x ** y)
print(type(x / y))

Output:

3
1
1000
<class 'float'>

Explanation:
10 // 3 = 3.
10 % 3 = 1.
10 ** 3 = 1000.
10 / 3 = 3.333... which is of type float.

Q3 (2 marks): What will be the output of the following code? Justify.

print('5' + '3')
print('Hi' * 3)
print(bool(0), bool(''), bool('hello'))

Output:

53
HiHiHi
False False True

Explanation:
'5' + '3' — Both operands are strings, so the + operator performs string concatenation, not arithmetic addition.
'Hi' * 3 — When multiplying a string by an integer, Python performs string repetition (repeats 'Hi' three times).
bool(0) → False (zero is a falsy value).
bool('') → False (an empty string is a falsy value).
bool('hello') → True (a non-empty string is a truthy value).

Q4 (2 marks): Write a Python program to accept a student's name and marks (out of 100) from the user and display: Student: <name> obtained <marks> marks.

Answer:

name = input('Enter student name: ')
marks = int(input('Enter marks: '))
print(f'Student: {name} obtained {marks} marks.')

Explanation: The input() function always returns a string. The marks variable is wrapped in int() to cast it to an integer so mathematical operations can be performed on it later if needed. The f-string neatly formats the variables into the output string.

Q5 (1 mark — MCQ): What is the output of print(int(7.9))?

A) 8
B) 7
C) 7.9
D) Error

Answer: B) 7.

Explanation: The int() function simply truncates (cuts off) the decimal part—it does NOT round the number. Therefore, int(7.9) gives 7, not 8. If rounding is required, the round(7.9) function must be used.

Q6 (2 marks): Identify the errors in the following variable names and state the reason:

(i) 2marks
(ii) my name
(iii) _total_marks
(iv) while

Explanation:

(i) 2marks — Invalid. Variable names cannot begin with a digit. They must start with a letter or an underscore.

(ii) my name — Invalid. Variable names cannot contain spaces. A valid alternative would be my_name or myName.

(iii) _total_marks — Valid. It starts with an underscore and contains only letters, digits, and underscores, which perfectly follows all naming rules.

(iv) while — Invalid. while is a reserved Python keyword and cannot be used as an identifier.

Q7 (2 marks): Write the output of the following code:

a, b, c = 10, 20, 30
print(a + b * c)
print((a + b) * c)
print(a ** 2 + b)
print(not (a > b))

Output:

610
900
120
True

Explanation (Operator Precedence):
10 + 20 * 30 → Multiplication (*) happens first: 10 + 600 = 610.
(10 + 20) * 30 → Parentheses happen first: 30 * 30 = 900.
10 ** 2 + 20 → Exponentiation (**) happens first: 100 + 20 = 120.
not (10 > 20) → Relational operator (>) is evaluated first. 10 > 20 is False. Then not False evaluates to True.

Related Study Material

More Informatics practices Notes More Python And Data Foundation Notes All Python Basics And Data Types Topics

Practice Questions

Informatics practices Practice Python Basics And Data Types Questions

Topic Information

DifficultyBeginner

Est. Read Time24 minutes

CategoryPython Basics And Data Types

Quick Actions

Track Your Learning

Study Tips

Take notes of key points while reading

Practice related questions after studying

Review topics marked as "Learning" regularly

Test your knowledge with practice questions

Edvaya Target

Detailed Notes & Solved Examples

Master complex concepts with our rich, topic-wise study notes. Access hundreds of step-by-step solved examples and interactive flashcards right from your phone.

Edvaya Target

Edvaya Aspire

Take a Free Mock Test

Target Subjects

Aspire Subjects

Subject Mastery

Python Basics — Variables, Data Types, Operators & I/O

1. Python — Introduction and Features

Key Features of Python

Python Execution Modes

2. Variables and Assignment

Rules for Variable Names (Identifiers)

3. Data Types in Python

Important Note: Dynamic Typing

4. Operators in Python

Arithmetic Operators

Comparison (Relational) Operators

Logical Operators

Operator Precedence (BODMAS for Python)

5. Input and Output

Output — `print()`

Input — `input()`

6. Type Conversion

7. Comments and Indentation

Output Prediction — Quick Reference

Practice Questions (CBSE Board Level)

Related Study Material

Practice Questions

Topic Information

Quick Actions

Track Your Learning

Study Tips

Edvaya Target

We Value Your Privacy

Edvaya Target

Edvaya Aspire

Take a Free Mock Test

Target Subjects

Aspire Subjects

Subject Mastery

Python Basics — Variables, Data Types, Operators & I/O

1. Python — Introduction and Features

Key Features of Python

Python Execution Modes

2. Variables and Assignment

Rules for Variable Names (Identifiers)

3. Data Types in Python

Important Note: Dynamic Typing

4. Operators in Python

Arithmetic Operators

Comparison (Relational) Operators

Logical Operators

Operator Precedence (BODMAS for Python)

5. Input and Output

Output — print()

Input — input()

6. Type Conversion

7. Comments and Indentation

Output Prediction — Quick Reference

Practice Questions (CBSE Board Level)

Related Study Material

Practice Questions

Topic Information

Quick Actions

Track Your Learning

Study Tips

Edvaya Target

We Value Your Privacy

Output — `print()`

Input — `input()`