Samacheer Kalvi Class 12 Computer Science Solutions Chapter 5 Python Variables and Operators

Samacheer Kalvi 12th Computer Science Guide Chapter 5 Python -Variables and Operators

I. Choose the Best Answer (1 Marks)

Question 1. Who developed Python?
(a) Ritche
(b) Guido Van Rossum
(c) Bill Gates
(d) Sunder Pitchai
Answer: (b) Guido Van Rossum
In simple words: Python was created by a Dutch programmer named Guido Van Rossum. He started working on it in the late 1980s.

🎯 Exam Tip: Knowing the creator of a programming language is a common general knowledge question, so remember Guido Van Rossum for Python.

Question 2. The Python prompt indicates that Interpreter is ready to accept instruction.
(a) > > >
(b) < < <
(c) #
(d) < <
Answer: (a) > > >
In simple words: When you open the Python interpreter, you will see three greater-than signs (>>>). This means Python is ready for you to type a command.

🎯 Exam Tip: The `>>>` prompt is specific to the interactive mode of Python, showing it's waiting for your input.

Question 3. Which of the following shortcut is used to create a new Python Program?
(a) Ctrl + C
(b) Ctrl + F
(c) Ctrl + B
(d) Ctrl + N
Answer: (d) Ctrl + N
In simple words: To start a completely new program file in Python's IDLE environment, you press the Ctrl key and the N key together. This is a common shortcut across many software programs for creating new files.

🎯 Exam Tip: Familiarize yourself with common keyboard shortcuts in your programming environment as they can save a lot of time.

Question 4. Which of the following character is used to give comments in Python Program?
(a) #
(b) &
(c) @
(d) $
Answer: (a) #
In simple words: In Python, you use the hash symbol (#) to make comments in your code. Anything written after # on that line is ignored by Python and is just for humans to read.

🎯 Exam Tip: Comments are crucial for making your code readable and understandable for others, and for your future self, especially in longer programs.

Question 5. This symbol is used to print more than one item on a single line.
(a) Semicolon(;)
(b) Dollor($)
(c) commaQ
(d) Colon(:)
Answer: (c) commaQ
In simple words: When you want to show several pieces of information on the same line using Python's print command, you separate them with a comma. The question's "commaQ" seems like a typo for "comma".

🎯 Exam Tip: Commas are used to separate arguments in the `print()` function, allowing multiple items to be displayed with a space in between them by default.

Question 6. Which of the following is not a token?
(a) Interpreter
(b) Identifiers
(c) Keyword
(d) Operators
Answer: (a) Interpreter
In simple words: In Python, tokens are the smallest parts of a program that have meaning, like words in a sentence. An interpreter is the program that runs your code, not a small part of the code itself.

🎯 Exam Tip: Remember that tokens are the basic building blocks of a program, while an interpreter is the engine that executes those blocks.

Question 7. Which of the following is not a Keyword in Python?
(a) break
(b) while
(c) continue
(d) operators
Answer: (d) operators
In simple words: Python has special words, called keywords, that it uses for its own functions and commands, like "break," "while," and "continue." "Operators" are types of symbols that do actions, but the word "operators" itself is not a keyword.

🎯 Exam Tip: Keywords are reserved words in Python and cannot be used as names for variables, functions, or any other identifier.

Question 8. Which operator is also called a Comparative operator?
(a) Arithmetic
(b) Relational
(c) Logical
(d) Assignment
Answer: (b) Relational
In simple words: Relational operators are used to compare two values, checking for relationships like "greater than" or "equal to." Because they compare things, they are also known as comparative operators.

🎯 Exam Tip: Relational operators (like <, >, ==, !=) always return a Boolean value (True or False) based on the comparison.

Question 9. Which of the following is not a Logical operator?
(a) and
(b) or
(c) not
(d) Assignment
Answer: (d) Assignment
In simple words: Logical operators like "and," "or," and "not" help combine or change true/false conditions. An assignment operator, typically represented by '=', is used to give a value to a variable, which is a different kind of operation.

🎯 Exam Tip: Logical operators are fundamental for creating complex conditions in control flow statements like `if` and `while`.

Question 10. Which operator is also called a Conditional operator?
(a) Ternary
(b) Relational
(c) Logical
(d) Assignment
Answer: (a) Ternary
In simple words: A ternary operator is a special type of operator that makes decisions based on a condition, much like an if-else statement, but in a more compact way. It's often called a conditional operator because its main purpose is to handle conditions.

🎯 Exam Tip: The ternary operator in Python allows you to write simple if-else logic on a single line, making your code concise for straightforward conditions.

II. Answer the Following Questions (2 Marks)

Question 1. What are the different modes that can be used to test Python Program?
Answer: Python programs can be written and run in two main ways: Interactive mode and Script mode. The Interactive mode lets you type and run Python commands one by one, immediately showing the results. This is useful for testing small pieces of code. Script mode allows you to write a complete program in a file (saved with a .py extension) and then run the whole file at once. This mode is used for creating and editing larger, full Python applications.
In simple words: Python programs can be tested in two ways: Interactive mode for quick, single-line commands and Script mode for writing and running entire programs saved in a file.

🎯 Exam Tip: Clearly define both modes and mention their primary use cases (testing vs. full program development) to score full marks.

Question 2. Write short notes on Tokens.
Answer: Tokens are the smallest individual units in a Python program that have meaning, similar to words in a sentence. Python breaks down each line of code into these basic building blocks during processing. Without tokens, the interpreter would not understand the program's structure. The main types of tokens in Python are:
1. Identifiers: Names given to variables, functions, etc.
2. Keywords: Special reserved words with specific meanings.
3. Operators: Symbols that perform operations (like +, -).
4. Delimiters: Symbols that mark boundaries (like parentheses, commas).
5. Literals: Fixed values (like numbers or text).
In simple words: Tokens are the smallest meaningful parts of a Python program, like tiny code words. Python breaks code into these units like identifiers, keywords, operators, delimiters, and literals to understand it.

🎯 Exam Tip: When explaining tokens, remember to list and briefly describe each of the five types to show comprehensive understanding.

Question 3. What are the different operators that can be used in Python?
Answer: In computer programming, operators are special symbols that perform computations, comparisons, or other actions on values. The values that an operator works on are called operands. Python categorizes its operators into several groups to handle different types of tasks. These categories include Arithmetic operators (for calculations like addition), Relational operators (for comparisons like checking if one value is greater than another), Logical operators (for combining true/false conditions), and Assignment operators (for giving values to variables). These different types help programmers perform a wide range of tasks in their code.
In simple words: Operators are special symbols in Python that do things like math, comparisons, or giving values to variables. They are grouped into types like Arithmetic, Relational, Logical, and Assignment operators.

🎯 Exam Tip: To get full marks, define what an operator is, briefly mention operands, and then list the main categories of operators used in Python.

Question 4. What is a literal? Explain the types of literals?
Answer: A literal is raw data that is directly provided in a variable or a constant within a program. It is a fixed value that does not change. Python supports various types of literals, which help to represent different kinds of data:
* **Numeric Literals:** These are numbers, like integers (whole numbers), floating-point numbers (numbers with decimals), and complex numbers.
* **String Literals:** These are sequences of characters (text) enclosed within single, double, or triple quotes.
* **Boolean Literals:** These represent truth values, which can only be `True` or `False`.
* **Special Literals:** Python also has special literals like `None`, which signifies the absence of a value.
In simple words: A literal is a fixed value written directly in code, like a number or text. Python has different kinds of literals such as numbers (Numeric), text (String), and true/false values (Boolean).

🎯 Exam Tip: When defining literals, make sure to clearly state that they are raw or fixed data and then enumerate and briefly describe each type with simple examples.

Question 5. Write short notes on Exponent data.
Answer: Exponent data is a way to represent very large or very small numbers in a concise format using scientific notation. It typically consists of a decimal part (mantissa), a decimal point, and an exponent part, which is usually indicated by 'E' or 'e' followed by one or more digits. The exponent tells you how many places to move the decimal point. For example, `12.E04` means 12 multiplied by \( 10^4 \), which is 120000. Similarly, `24.e04` represents \( 24 \times 10^4 \), which is 240000. This notation makes handling very big or very small numbers much easier in programming.
In simple words: Exponent data helps write very big or very small numbers in a shorter way using 'E' or 'e'. It has a number part and a power part, like `12.E04` means 12 with four zeros after it.

🎯 Exam Tip: When explaining exponent data, remember to include examples that clearly show both the decimal and exponent parts and how they combine to form the final number.

III. Answer the Following Questions (3 Marks)

Question 1. Write short notes on the Arithmetic operator with examples.
Answer: Arithmetic operators are mathematical symbols used to perform calculations on two numbers (operands). They are fundamental for basic math in programming. Python supports a variety of arithmetic operators to handle different types of sequential calculations. These operators are essential for any numerical processing in a program. For example, if we assume variable \( a = 100 \) and \( b = 10 \):
* `+` (Addition): Adds two operands. Example: `>>> a+b` gives `110`
* `-` (Subtraction): Subtracts the second operand from the first. Example: `>>> a-b` gives `90`
* `*` (Multiplication): Multiplies two operands. Example: `>>> a*b` gives `1000`
* `/` (Division): Divides the first operand by the second, always returning a float. Example: `>>> a/b` gives `10.0`
* `%` (Modulus): Returns the remainder of a division. Example: `>>> a%30` gives `10` (100 divided by 30 is 3 with a remainder of 10)
* `**` (Exponent): Raises the first operand to the power of the second. Example: `>>> a**2` gives `10000` (100 squared)
* `//` (Floor Division): Divides and returns only the integer part of the quotient (rounds down). Example: `>>> a//30` gives `3`
In simple words: Arithmetic operators are like the math symbols you use for adding, subtracting, multiplying, and dividing numbers in Python. They help you do calculations, like how `+` adds two numbers together.

🎯 Exam Tip: When providing examples for operators, choose simple numbers to demonstrate their function clearly and ensure you include the operator, operation, example, and expected result for each.

Question 2. What are the assignment operators that can be used in Python?
Answer: Assignment operators in Python are used to assign values to variables. The most basic assignment operator is the equals sign (`=`), which simply gives a value to a variable. For instance, `x = 10` means `x` now holds the value 10. Python also provides several compound assignment operators that combine an arithmetic operation with an assignment, making the code shorter and often more readable. These operators perform an operation and then assign the new result back to the original variable. For example, `x += 5` is the same as `x = x + 5`. Other common compound assignment operators include `-=`, `*=`, `/=`, `%=`, `**=`, and `//=` which work similarly for subtraction, multiplication, division, modulus, exponentiation, and floor division respectively.
Consider \( x = 10 \):
* `=` (Simple Assignment): Assigns the right-side operand to the left-side variable. Example: `>>> x=10` or `>>> b="Computer"`
* `+=` (Add and Assign): Adds the right operand to the left operand and assigns the result to the left operand. Example: `>>> x+=20` is same as `x=x+20`
* `-=` (Subtract and Assign): Subtracts the right operand from the left operand and assigns the result to the left operand. Example: `>>> x-=5` is same as `x=x-5`
In simple words: Assignment operators help put values into variables. The simple `=` sign gives a value directly, while others like `+=` do a math calculation first and then store the new result back into the variable.

🎯 Exam Tip: When discussing assignment operators, always mention the basic `=` operator first, then explain compound assignment operators with clear examples to show how they shorten code.

Question 3. Explain the Ternary operator with examples.
Answer: The ternary operator, also known as a conditional operator, is a special operator that evaluates a condition and returns one value if the condition is true and another value if the condition is false. It acts as a compact way to write simple `if-else` statements on a single line, making the code more concise. This operator helps make code cleaner when dealing with short conditional assignments. The basic syntax in Python is `[value_if_true] if [condition] else [value_if_false]`.
For example, to find the minimum of two numbers, we can write:
`min = 50 if 49 < 50 else 70`
Here, since `49 < 50` is true, `min` will be assigned `50`.
Another example:
`min = 50 if 49 > 50 else 70`
Here, since `49 > 50` is false, `min` will be assigned `70`.
In simple words: A ternary operator lets you pick between two values based on a true or false condition, all on one line. It's a quick way to say "if this is true, use that; otherwise, use this other thing."

🎯 Exam Tip: Clearly state the syntax of the ternary operator in Python and provide simple examples to illustrate how it assigns a value based on a condition.

Question 4. Write short notes on Escape sequences with examples.
Answer: In Python strings, the backslash character `\` is special. It is known as the "escape" character because it changes the meaning of the character that comes right after it. Escape sequences are used to represent characters that are difficult or impossible to type directly into a string, such as new lines, tabs, or even a backslash itself. They help format text output exactly as needed. For example, `\t` represents a tab, `\n` creates a new line, and `\r` is a carriage return. To print a literal backslash, you need to use `\\`.
* For example, to print the message "It's raining", if you use `print ("It \'s raining")`, the output is: `It's raining`
Here's a table of common escape sequences:

🎯 Exam Tip: Remember that the backslash `\` is the key to all escape sequences; if you want to print a literal backslash, you must use two of them (`\\`).

Question 5. What are string literals? Explain.
Answer: String literals are sequences of characters (text) enclosed within quotation marks in Python. These quotes can be single (`'...'`), double (`"..."`), or triple (`'''...'''` or `"""..."""`). String literals are used to represent text data in your program. Python is very flexible with how you define strings, allowing you to choose the quote type that best suits your needs, especially for including quotes within a string itself. Triple quotes are particularly useful for creating multi-line strings, where the text spans across several lines in the code, or for strings that contain both single and double quotes without needing escape characters.
Example:
`Strings = "This is Python"`
`char = 'C'`
`multiline_str = """This is a multiline string with more than one line code"""`
In simple words: String literals are just text in Python, written inside single, double, or triple quotes. They are used to store words, sentences, or any character data in your program.

🎯 Exam Tip: Explain all three types of string quotation (single, double, triple) and highlight the advantage of triple quotes for multi-line strings.

IV. Answer the Following Questions (5 Marks)

Question 1. Describe in detail the procedure Script mode programming.
Answer: Script mode programming in Python involves writing a complete program in a text file, usually with a `.py` extension, and then executing the entire file. This method is used for developing larger, reusable applications, unlike interactive mode which is for quick tests. The main steps for script mode programming are:
* **Creating a Script:** You begin by opening a new file in your Python development environment (like IDLE). This file is essentially a text file where you type your Python statements. For example, you might type: `a=100`, `b=350`, `c=a+b`, `print("The Sum=",c)`. Python scripts are just simple text files containing Python instructions.
* **Saving the Script:** After writing your code, you must save the file. Use "File → Save" or the shortcut `Ctrl+S`. A "Save As" dialog box will appear. Choose a location to save your file and give it a name, making sure it ends with `.py` (e.g., `myprogram.py`). Python automatically saves files with this extension. Saving the script makes your code reusable, so you don't have to type it again.
* **Executing the Script:** To run your saved Python script, you can go to "Run → Run Module" or simply press `F5` in IDLE. If your code has any errors, Python's IDLE window will show them in red, along with a description of the error type. You then go back to the script editor, fix the errors, save the file (`Ctrl+S`), and run it again. Once all errors are fixed, the script will execute, and its output will appear in the IDLE window. Scripts are editable, allowing for easy updates and corrections.
In simple words: Script mode means writing your Python program in a separate file, saving it, and then running the whole file at once. You write code, save it with a `.py` name, and press F5 to make it run. It's great for making full programs that you can use many times.

🎯 Exam Tip: Detail the three key stages: creation, saving, and execution. Emphasize the `.py` extension and the debugging process (error identification and correction) for a complete answer.

Question 2. Explain input () and print() functions with examples.
Answer: In Python, `input()` and `print()` are two fundamental functions used for interacting with the user and displaying results.
**`input()` function:**
The `input()` function is used to get data (input) from the user while the program is running. It reads a line from the input (usually the keyboard) and returns it as a string. You can provide a "prompt string" inside the parentheses to tell the user what to type. If no prompt is given, the user won't see a message, which can be confusing. It is important to remember that `input()` always returns data as a string, even if the user types numbers. If you need to use the input as a number, you must convert it using functions like `int()` or `float()`.
Syntax: `variable = input("prompt string")`
Example:
`>>> city=input("Enter Your City: ")`
(User types) `Madurai`
`>>> print("I am from ", city)`
(Output) `I am from Madurai`
Example for numeric input:
`x = int(input("Enter Number 1: "))`
`y = int(input("Enter Number 2: "))`
`print("The sum =", x+y)`
Output:
`Enter Number 1: 34`
`Enter Number 2: 56`
`The sum = 90`

**`print()` function:**
The `print()` function is used to display output on the screen. It can show text, numbers, or the values of variables. You can print a single item or multiple items by separating them with commas. By default, `print()` adds a space between items and a new line at the end. It evaluates any expressions given to it before displaying the result. This function is vital for seeing the results of your code and providing feedback to the user.
Syntax:
`print("string to be displayed as output")`
`print(variable)`
`print("String to be displayed as output variable")`
`print("String 1", variable, "String 2", variable, "String 3")`
Example:
`>>> print("Welcome to Python Programming")`
(Output) `Welcome to Python Programming`
`x = 5`
`y = 6`
`z = x+y`
`>>> print(z)`
(Output) `11`
`>>> print("The sum =",z)`
(Output) `The sum=11`
`>>> print("The sum of", x, "and ", y, "is ", z)`
(Output) `The sum of 5 and 6 is 11`
In simple words: The `input()` function lets your program ask the user for information, and the `print()` function shows messages or results back to the user on the screen. `input()` gets text, and `print()` shows text or numbers.

🎯 Exam Tip: For `input()`, emphasize that it always returns a string and requires explicit type conversion for numbers. For `print()`, highlight its ability to display multiple items and its role in outputting results.

Question 3. Discuss in detail about Tokens in Python
Answer: In Python, a program is essentially a sequence of instructions. Before the Python interpreter can understand and run these instructions, it first breaks down each logical line of code into its smallest meaningful parts. These parts are called "tokens." Think of tokens as the individual "words" and "punctuation" that make up the language of Python. Every character in a Python program contributes to forming these tokens, which the interpreter then uses to build the program's structure. Understanding tokens is key to understanding how Python interprets code. The primary types of tokens in Python are:

**1. Identifiers:**
Identifiers are names used to identify variables, functions, classes, modules, or other objects in Python. They are like labels that you give to different parts of your code. An identifier must start with an alphabet (A-Z or a-z) or an underscore (_). After the first character, it can contain letters, numbers (0-9), or underscores. Python identifiers are case-sensitive, meaning `myVar` is different from `myvar`. Also, identifiers cannot be Python keywords (reserved words) and cannot contain punctuation characters like `%, $, @`, etc.

**2. Keywords:**
Keywords are special, reserved words in Python that have specific meanings to the interpreter. They are used to define the structure and logic of a program. Because keywords have these predefined meanings, you cannot use them as identifiers (names for your variables, functions, etc.). Examples include `if`, `else`, `while`, `for`, `def`, `class`, `import`, `return`, `True`, `False`, `None`, etc. Python uses keywords to understand what you want the program to do.

**3. Operators:**
Operators are special symbols that perform calculations or actions on one or more values (called operands). For example, `+` is an operator for addition, `==` is an operator for comparison, and `=` is an operator for assignment. Python categorizes operators into types such as arithmetic, relational, logical, and assignment operators, each serving a distinct purpose in performing computations or making decisions within the program.

**4. Delimiters:**
Delimiters are symbols or symbol combinations that are used to structure expressions, lists, dictionaries, tuples, and strings in Python. They mark boundaries and separate different parts of the code. Common delimiters include parentheses `()`, square brackets `[]`, curly braces `{}` for grouping and defining data structures, commas `,` for separating items, colons `:` for indicating blocks, and semicolons `;` (though less common in modern Python, they can separate statements on a single line).

**5. Literals:**
Literals are fixed, raw data values that are directly given in a variable or a constant in a Python program. They represent specific values like numbers, text, or true/false conditions directly in the code. Python supports various types of literals:
* **Numeric Literals:** Numbers like integers (e.g., `10`, `100`), floating-point numbers (e.g., `3.14`, `0.5`), and complex numbers.
* **String Literals:** Sequences of characters enclosed in quotes (e.g., `"Hello"`, `'Python'`).
* **Boolean Literals:** Represent truth values (`True` or `False`).
* **Special Literals:** `None` (represents the absence of a value).
In simple words: Tokens are the smallest pieces of a Python program that make sense to the computer, like individual words. These include names you make up (identifiers), special words Python uses (keywords), symbols that do actions (operators), symbols that separate parts of code (delimiters), and actual fixed values like numbers or text (literals).

🎯 Exam Tip: Provide a clear definition of tokens and then thoroughly explain each of the five types (Identifiers, Keywords, Operators, Delimiters, Literals) with characteristics and examples for each to ensure a comprehensive answer.

12th Computer Science Guide Python -Variables and Operators Additional Questions and Answers

I. Choose the best answer (1 Mark)

Question 1. Python language was released in the year
(a) 1992
(b) 1994
(c) 1991
(d) 2001
Answer: (c) 1991
In simple words: Python first came out in 1991. This marked the start of a new programming language for developers.

🎯 Exam Tip: Remember important dates related to programming language origins for general knowledge.

Question 2. CWI means
Answer: Centrum Wiskunde & Information
In simple words: CWI means 'Centrum Wiskunde & Informatica'. It is a research center for mathematics and computer science.

🎯 Exam Tip: Acronyms and their full forms are often tested, so learn them precisely.

Question 3. In Python, How many ways programs can be written?
(a) 4
(b) 2
(c) 3
(d) many
Answer: (b) 2
In simple words: You can write Python programs in two ways: Interactive mode and Script mode. These modes offer flexibility in how code is developed and executed.

🎯 Exam Tip: Understand the difference between Interactive mode (direct execution) and Script mode (saving as a file) for Python programming.

Question 4. Find the wrong statement from the following.
(a) Python supports procedural approaches
(b) Python supports object-oriented approaches
(c) Python is a DBMS tool
Answer: (c) Python is a DBMS tool
In simple words: Python is a programming language, not a tool for managing databases. It supports both procedural and object-oriented programming styles.

🎯 Exam Tip: Be clear about what Python is (a programming language) and what it is not (like a database management system).

Question 5. Which mode displays the python code result immediately?
(a) Compiler
(b) Script
(c) Interactive
(d) program
Answer: (c) Interactive
In simple words: Interactive mode in Python shows the result of the code immediately. This is useful for testing small snippets of code quickly.

🎯 Exam Tip: Interactive mode is great for quick tests and learning, while script mode is for larger, saved programs.

Question 6. Which of the following command is used to execute the Python script?
(a) Run \( \rightarrow \) Python Module
(b) File \( \rightarrow \) Run Module
(c) Run \( \rightarrow \) Module Fun
(d) Run \( \rightarrow \) Run Module
Answer: (d) Run \( \rightarrow \) Run Module
In simple words: To execute a Python script, the command used is "Run \( \rightarrow \) Run Module". This option starts the script in the Python interpreter.

🎯 Exam Tip: Know the exact menu path or shortcut to run a Python script in your development environment.

Question 7. The extension for the python file is
(a) .pyt
(b) .pt
(c) .py
(d) .pyth
Answer: (c) .py
In simple words: The standard file extension for a Python script is .py. This helps the operating system identify it as a Python program.

🎯 Exam Tip: File extensions are crucial for how operating systems and software identify and handle different file types.

Question 8. Which operator replaces multiline if-else in python?
(a) Local
(b) Conditional
(c) Relational
(d) Assignment
Answer: (b) Conditional
In simple words: The Conditional operator, also known as the Ternary operator, can replace multiline if-else statements in Python. It allows writing a conditional expression in a single line.

🎯 Exam Tip: Conditional operators make code shorter and more readable for simple if-else logic, but complex conditions are better with full if-else blocks.

Question 9. Which of the following is a sequence of characters surrounded by quotes?
(a) Complex
(b) String literal
(c) Boolean
(d) Octal
Answer: (b) String literal
In simple words: A sequence of characters enclosed by quotes (single, double, or triple) in Python is called a String literal. This is how text data is represented.

🎯 Exam Tip: Always remember that strings in Python are defined by enclosing characters in quotes.

Question 10. What does prompt (> > >) indicator?
(a) Compiler is ready to debug
(b) Results are ready
(c) Waiting for the Input data
(d) Interpreter is ready to accept Instructions
Answer: (d) Interpreter is ready to accept Instructions
In simple words: The prompt '>>>' indicates that the Python Interpreter is ready to accept instructions. This is seen in the interactive mode of Python.

🎯 Exam Tip: Recognizing the '>>>' prompt is key to knowing you are in Python's interactive mode and can start typing commands.

Question 11. In Python shell window opened by pressing.
(a) Alt + N
(b) Shift + N
(c) Ctrl + N
(d) Ctrl + Shift +N
Answer: (c) Ctrl + N
In simple words: To open a new Python shell window, you typically press Ctrl + N. This creates a new script editor window in the IDLE environment.

🎯 Exam Tip: Keyboard shortcuts can save a lot of time when coding, so try to learn the most common ones.

Question 12. In Python, comments begin with
(a) /
(b) #
(c) \
(d) //
Answer: (b) #
In simple words: In Python, comments begin with the hash symbol (#). Anything written after '#' on the same line is ignored by the interpreter and is used for human readability.

🎯 Exam Tip: Use comments frequently to explain your code, making it easier for yourself and others to understand later.

Question 13. Which command is selected from the File menu creates a new script text editor?
(a) New
(b) New file
(c) New editor
(d) New Script file
Answer: (b) New file
In simple words: From the File menu, selecting "New File" creates a new script text editor. This is where you write and save your Python programs in script mode.

🎯 Exam Tip: Always save your work regularly using a descriptive file name to avoid losing progress.

Question 14. Python uses the symbols and symbol combinations as \(\dots\) in expressions
(a) literals
(b) keywords
(c) delimiters
(d) identifiers
Answer: (c) delimiters
In simple words: Symbols like parentheses or commas are used as 'delimiters' to separate parts of your Python code. Delimiters help define the structure and separation of elements in the code.

🎯 Exam Tip: Understanding delimiters helps in writing syntactically correct code, as they dictate how different parts of an expression or statement are grouped.

Question 15. All data values in Python are
(a) class
(b) objects
(c) type
(d) function
Answer: (b) objects
In simple words: In Python, every piece of data is treated as an 'object'. This means everything you work with, from numbers to strings, is an instance of some class.

🎯 Exam Tip: Python's "everything is an object" philosophy is a core concept that influences how data behaves and is manipulated.

Question 16. \(\dots\) command is used to execute python script?
(a) Run
(b) Compile
(c) Run \( \rightarrow \) Run Module
(d) Compile \( \rightarrow \) Compile Run
Answer: (c) Run \( \rightarrow \) Run Module
In simple words: To run a Python script, use the "Run \( \rightarrow \) Run Module" command. This action starts the script in the Python environment.

🎯 Exam Tip: Make sure your script is saved before trying to run it, especially after making changes.

Question 17. Octal integer uses \(\dots\) to denote octal digits
(a) OX
(b) O
(c) OC
(d) Od
Answer: (b) O
In simple words: The letter 'O' (or 'o') is used to show an octal number. This prefix helps distinguish octal numbers from decimal numbers.

🎯 Exam Tip: Different number systems like octal (base 8) and hexadecimal (base 16) have specific prefixes in Python to indicate their base.

Question 18. Find the hexadecimal Integer.
(a) 0102
(b) 0876
(c) 0432
(d) 0X102
Answer: (d) 0X102
In simple words: '0X102' is a hexadecimal number because it starts with '0X'. In Python, hexadecimal numbers are prefixed with '0x' or '0X'.

🎯 Exam Tip: Remember the common prefixes: '0b' for binary, '0o' for octal, and '0x' for hexadecimal in Python.

Question 19. How many floating-point values are there is a complex number?
(a) 1
(b) 2
(c) 3
(d) 4
Answer: (b) 2
In simple words: A complex number has two parts, both of which are floating-point numbers. These represent the real part and the imaginary part of the complex number.

🎯 Exam Tip: Complex numbers combine a real part and an imaginary part, each represented by a floating-point number.

II. Answer the following questions (2 and 3 Marks)

Question 1. Write a note on keywords. Give examples?
Answer: Keywords are special words used by Python interpreters to recognize the structure of the program. These words have specific meanings and cannot be used for any other purpose. Examples include 'while' and 'if'. Keywords are fundamental for writing valid Python code.
In simple words: Keywords are special words Python understands. They help Python know what to do and cannot be used for other things. For example, 'if' and 'while' are keywords.

🎯 Exam Tip: Understanding and correctly using keywords is essential for writing error-free Python programs.

Question 2. What are keywords? Name any four keywords in Python.
Answer: Keywords are special, reserved words in Python that have predefined meanings and perform specific functions in the language. They are used by the Python interpreter to understand the structure and logic of the program.
Four keywords in Python are: 'false', 'class', 'finally', and 'return'. There are many others, each serving a unique purpose.
In simple words: Keywords are special words in Python that mean certain things and cannot be used for other names. Some examples are 'false', 'class', 'finally', and 'return'.

🎯 Exam Tip: Knowing common keywords helps you avoid using them as variable names, which would cause errors.

Question 3. Write a note on the relational or comparative operator.
Answer: A Relational operator, also known as a Comparative operator, is used to check the relationship between two operands. These operators compare two values and return either True or False based on the comparison. For example, checking if one number is greater than another is a relational operation.
In simple words: Relational operators compare two things. They tell you if something is true or false, like if one number is bigger than another.

🎯 Exam Tip: Relational operators are crucial for decision-making in programs, as they form the basis of conditions in 'if' statements and loops.

Question 4. Write a short note on the comment statement.
Answer: In Python, comment statements are used to add explanations or notes within the code. Comments begin with a hash symbol (#) and are ignored by the Python interpreter during execution. They make the code more readable and understandable for humans. Multiline comments can be enclosed within three hash symbols, like '### This is a multiline comment ###'.
In simple words: Comments are notes in your code that Python ignores. You start them with a '#' symbol. They help people understand what your code does.

🎯 Exam Tip: Always add comments to complex parts of your code to clarify their purpose, improving code maintainability.

Question 5. What are the key features of python?
Answer: Python is a versatile, general-purpose programming language. Its key features include being platform-independent, meaning code written on one operating system can run on another. Python programs are also known for being easily readable and understandable due to their clear syntax. It is widely used for both scientific and non-scientific programming.
In simple words: Python is easy to use and understand. It works on many different computers. You can use it for many kinds of tasks, both for science and other things.

🎯 Exam Tip: Focus on Python's readability, versatility, and platform independence as core advantages in your answer.

Question 6. What are the uses of the logical operators? Name the operators.
Answer: In Python, logical operators are used to perform logical operations on given relational expressions. They combine or modify Boolean values (True or False).
The three logical operators in Python are: 'and', 'or', and 'not'. These operators are essential for creating complex conditions in programming.
In simple words: Logical operators help combine or change True/False conditions in Python. The three main ones are 'and', 'or', and 'not'.

🎯 Exam Tip: Practice using logical operators to build more precise conditions in your 'if' statements and loops.

III. Answer the following questions (5 Marks)

Question 1. Explain data types in python?
Answer: In Python, all data values are treated as objects, and each object has a specific type. Python includes several built-in or fundamental data types to handle different kinds of values. These types help define what kind of operations can be performed on the data and how it is stored.
Python's main built-in data types include:
1. **Numbers:** Used for numerical values. This category further includes:
    - **Integers:** Whole numbers (e.g., 102, 4567). Octal integers use '0o' or '0O' prefix (e.g., 0o102), and hexadecimal integers use '0x' or '0X' prefix (e.g., 0X102).
    - **Floating-point numbers:** Numbers with a decimal point (e.g., 123.34, 456.23). They can also use an exponent part (e.g., \( 12.E04 \)). These are good for precise calculations.
    - **Complex numbers:** Made up of two floating-point values: a real part and an imaginary part (e.g., \( 3 + 4j \)).
2. **String:** Used for sequences of characters. Strings are enclosed within single, double, or triple quotes (e.g., 'A', "Computer Science", """Multi-line string""").
3. **Boolean:** Represents truth values, either True or False. These are fundamental for logical operations.
Other data types include Tuples, Lists, and Dictionaries, which are used for collections of data.
In simple words: Data types tell Python what kind of information you are working with, like whole numbers, numbers with decimals, text, or true/false values. This helps Python know how to store and use the data correctly.

🎯 Exam Tip: Be sure to define each data type clearly, provide examples for each, and explain their purpose in Python programming.