Big picture
Python programs express algorithms in a language that a computing environment can execute. A small fee calculator already needs meaningful names, suitable data types, correct arithmetic and clear output. Good programming begins with these choices, before loops or large applications.
This chapter develops the vocabulary needed to read, write and debug short programs. Trace the supplied examples and distinguish the value of an expression from the text used to display it. Small differences such as quoted digits, a missing colon or an unexpected conversion can completely change a program's behaviour.
Learning goals
Design a simple algorithm before writing code.
Identify tokens, identifiers and literals.
Distinguish common types and assignment behaviour.
Convert input and format output deliberately.
Evaluate operators and classify programming errors.
Core ideas
1. Problem solving and program development
An algorithm is a finite, ordered set of unambiguous steps for solving a problem. Before writing Python, identify inputs, required outputs and the relation between them. For a stationery bill, inputs might be quantity and price per item; output is their product. An algorithm can first be written in ordinary language or pseudocode.
A flowchart uses a terminator for start/end, a parallelogram for input/output, a rectangle for processing and a diamond for a decision. Arrows show control flow. Design, implementation, testing and correction form an iterative cycle: discovering an unhandled input should lead to improving the algorithm, not merely changing a printed answer. Test normal, boundary and invalid inputs separately because success on one sample does not establish correctness.
2. Interactive and script execution
The interactive mode evaluates instructions entered at a prompt; it is useful for experimenting with a short expression. A script stores instructions in a file and executes them as a program. Prompt symbols are part of the interactive interface and should not be copied into a script.
Python uses indentation to group statements in a block. Consistent spaces communicate structure to both interpreter and reader. A comment begins with # outside a string and documents intent; it is not executed as a statement. For example, explaining why a school rounds a bill is more useful than a comment that simply repeats “add one.” Python is case-sensitive, so total and Total identify different names. Keep descriptive naming consistent throughout an example.
3. Tokens and valid identifiers
Tokens are meaningful lexical units: keywords, identifiers, literals, operators and delimiters. Keywords such as if, while and True have reserved roles. Identifiers name variables and other program elements. A safe school-level identifier uses letters, digits and underscores, does not begin with a digit, and is not a keyword.
Thus fee_total and _count are valid, while 2fees, class and fee-total are unsuitable identifiers: the last is parsed using subtraction. Literals directly express values, including 14, 2.75, 'Pune', True and None. Quotes distinguish a string literal from a name. Delimiters such as parentheses and commas organise expressions and calls. Choose names such as unit_price rather than x when the purpose is a bill, since meaningful names reduce errors during later tracing.
4. Objects, assignment and data types
A variable is a name bound to an object. Assignment evaluates the right side and binds the result to the left-side name. Reassigning score from an integer to a string is permitted, but later operations must suit the new type. Python's dynamic typing does not mean types cease to matter.
Type | Example | Important feature |
|---|---|---|
int | 18 | Whole-number arithmetic |
float | 3.5 | Approximate real-number representation |
complex | 2+3j | Real and imaginary components |
bool | True | Logical value |
str | '18' | Immutable text |
NoneType | None | Absence of a useful value |
For a = 6 followed by b = a, both names initially refer to the integer value. Rebinding a to 9 does not change b. Multiple assignment can swap bindings with a, b = b, a; the right-hand values are evaluated before assignment.
5. Input, output and conversion
input() returns a string even when a user types digits. Convert deliberately with int or float before numeric arithmetic. int('24') is valid, while int('2.4') raises ValueError; a decimal-looking string must first be interpreted as a suitable numeric form. Do not execute untrusted input as code to avoid writing a conversion.
print() displays values, with sep controlling the separator and end controlling the ending. str converts a value into text for composition. Type conversion changes representation, not the user's intention: converting a price to int can discard its fractional part. For predictable examples, supply fixed literals or document input assumptions. If a question asks for exact output, account for spaces, punctuation and line breaks rather than giving only the numeric result.
6. Operators, precedence and a tested bill
Arithmetic includes +, -, , /, //, %, and *. True division / returns a floating-point result; floor division // rounds toward negative infinity. Remainder satisfies a = b × (a // b) + a % b for nonzero b. Exponentiation groups from the right, and parentheses make intended order explicit.
quantity = int("7")
price = 12
total = quantity * price
print(total, total / 5)
print(-9 // 4, -9 % 4)
print(3 + 2 * 5 ** 2)
print("Bill", total, sep=": ")Output:
84 16.8
-3 3
53
Bill: 84The bill is 7 × ₹12 = ₹84. The floor result is −3 because it must not exceed −2.25; the remainder is 3 because −9 = 4 × (−3) + 3. Exponentiation is applied before multiplication and addition. These calculations should be traced independently, rather than inferred from the visual order of symbols.
7. Comparisons, logic and expression meaning
Comparison operators include ==, !=, <, <=, > and >=. Assignment = binds a name; == checks equality. Logical not, and and or combine conditions. Membership in tests whether an element occurs in a collection; identity is tests whether references identify the same object. Use equality rather than identity to compare ordinary numeric or text values.
For integers, 4 < 7 is a Boolean comparison; '4' + '7' concatenates strings instead of performing numeric addition. Mixing a string and integer with + raises TypeError. Truthiness allows empty strings and zero to behave as false in conditions, but make intentions explicit when teaching a rule. A valid expression can still implement the wrong formula: tax added before a discount can differ from the policy actually requested.
8. Errors, testing and readable solutions
A syntax error violates the language grammar, such as an unclosed parenthesis. A runtime error occurs during execution, such as division by zero or converting unsuitable text. A logical error produces an incorrect result even though the program runs. These categories require different corrections.
Suppose a rectangle program adds length and breadth when area is requested. The syntax can be valid and no exception occurs, yet multiplication is required. Record expected results from hand working before testing so that a program's own output is not mistaken for proof. A useful trace table records the statement, value and type after each assignment. For longer answers, separate input, processing and output visibly, choose meaningful names, and explain any assumptions about permitted values. This makes the solution easier to test and to mark.
A reliable approach to questions
Read the command word before choosing an answer. A definition needs the distinguishing feature; a comparison needs matching criteria on both sides; an application needs a reason linked to the situation.
Extract the supplied evidence and assumptions. Keep a small working table rather than relying on memory. If information is absent, state the limit instead of inventing a value or claiming certainty.
Work through the relevant rule one step at a time. For a program, record the changing state; for a scenario, connect the requirement to the feature that meets it. Explain why the closest alternative fails.
Check the result against the original question, including boundary cases, units and wording. Present a concise final answer followed by enough reasoning for another student to reproduce your conclusion.
Connections that matter
Boolean logic explains compound comparison conditions.
Selection and iteration extend sequential algorithms with branches and repetition.
Collections organise multiple values instead of isolated variable names.
Common mistakes
Using = to compare values: use == for equality.
Assuming input returns a number: convert the returned string.
Treating floor division as truncation: negative results round downward.
Calling every wrong result a syntax error: valid code can contain a logical error.
Revision checklist
I can design a simple algorithm before writing code.
I can identify tokens, identifiers and literals.
I can distinguish common types and assignment behaviour.
I can convert input and format output deliberately.
I can evaluate operators and classify programming errors.