Scribd
Upload
48 views4 pages

Python Exam Notes

The document provides a comprehensive guide on Python fundamentals, including basic data types, operators, control flow, functions, modules, exception handling, and object-oriented programming concepts such as classes, objects, and inheritance. It includes examples and explanations for each topic to aid in exam preparation. Mastery of these concepts is essential for success in Python programming.

Uploaded by

deepgupta.iimun
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
48 views4 pages

Python Exam Notes

The document provides a comprehensive guide on Python fundamentals, including basic data types, operators, control flow, functions, modules, exception handling, and object-oriented programming concepts such as classes, objects, and inheritance. It includes examples and explanations for each topic to aid in exam preparation. Mastery of these concepts is essential for success in Python programming.

Uploaded by

deepgupta.iimun
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd

Python Exam Guide

2. Basic Data Types and Operators

Numeric Types

 int: Integer numbers (e.g., 10, -5)

 float: Decimal numbers (e.g., 10.5, -3.14)

 boolean: True or False (subtype of int where True=1, False=0)

 complex: Numbers with real and imaginary parts (e.g., 3+2j)

Type Casting and Conversion

 Convert between types using int(), float(), str(), etc.

 Example:

 x = int(3.8) # x becomes 3

 y = float("5.6") # y becomes 5.6

Operators

Arithmetic Operators

 + (addition), - (subtraction), * (multiplication), / (division)

 // (floor division), % (modulus), ** (exponentiation)

Logical Operators

 and (both conditions must be true)

 or (at least one condition must be true)

 not (negates the condition)

Comparison Operators

 ==, !=, >, <, >=, <=

3. Control Flow

Conditional Statements

Used to execute different blocks of code based on conditions.

x = 10

if x > 5:

print("Greater")

elif x == 5:
print("Equal")

else:

print("Smaller")

Loops

For Loop (Used to iterate over sequences like lists, tuples, etc.)

for i in range(3):

print(i) # Outputs: 0, 1, 2

While Loop (Repeats as long as a condition is true)

x=5

while x > 0:

print(x)

x -= 1

List Comprehension (Shorter way to create lists)

squares = [x**2 for x in range(5)] # [0, 1, 4, 9, 16]

4. Functions, Modules, and Exception Handling

Defining Functions

def greet(name):

return "Hello, " + name

Function Parameters and Arguments

 Positional Arguments: Must be passed in order.

 Keyword Arguments: Passed with parameter names.

 Default Arguments: Have default values if not provided.

 Variable-Length Arguments:

 def add(*args):

 return sum(args)

Scope: Local vs Global Variables

 Local Variable: Defined inside a function.

 Global Variable: Defined outside functions and can be accessed anywhere.

 global keyword can be used to modify a global variable inside a function.

Exception Handling
Prevents program crashes by handling errors.

try:

x=5/0

except ZeroDivisionError:

print("Cannot divide by zero!")

finally:

print("Execution finished")

5. Object-Oriented Programming (OOP) Basics

Classes and Objects

 A class is a blueprint for creating objects.

 An object is an instance of a class.

class Car:

def __init__(self, brand):

[Link] = brand

car1 = Car("Toyota")

print([Link]) # Toyota

Attributes and Methods

 Attributes are variables that store object data.

 Methods are functions defined inside a class.

class Dog:

def __init__(self, name):

[Link] = name

def bark(self):

print("Woof!" )

Encapsulation

Restricting direct access to an object's data.

 Public Attribute: Accessible from anywhere ([Link])

 Protected Attribute: Indicated with _ (self._name)

 Private Attribute: Indicated with __ (self.__name)


Inheritance

Inheritance allows a class (child class) to acquire properties and methods of another class (parent
class).

Single Inheritance (Child inherits from one parent)

class Vehicle:

def __init__(self, brand):

[Link] = brand

class Car(Vehicle):

pass

Multiple Inheritance (Child inherits from multiple parents)

class A:

pass

class B:

pass

class C(A, B):

pass

Multilevel Inheritance (Child → Parent → Grandparent)

class Grandparent:

pass

class Parent(Grandparent):

pass

class Child(Parent):

pass

Conclusion

This document covers Python fundamentals up to Inheritance. Understanding these topics will
help you prepare effectively for your exam. Let me know if you need further explanations or
additional practice questions!

Common questions

Powered by AI

Inheritance allows a new class to inherit properties and methods from an existing class, which helps in minimizing redundancy and promoting code reusability. By defining common features in a base class, subclasses can extend or override these features to suit specific needs. This reduces the amount of code a programmer has to write and maintain, as changes in the parent class automatically propagate to child classes unless explicitly overridden. For example, a Car class inheriting from a Vehicle class can reuse attributes like 'brand' without redefining them .

Type casting and conversion can be crucial in scenarios that involve data input and user interaction, where data might be received as strings but need to be used as numeric types for computation. For example, converting a user-entered numeric value from a string to a float or int ensures that arithmetic operations can be performed correctly. Such conversion ensures data integrity and avoids runtime errors by maintaining consistency in data types throughout program execution .

Using *args in Python functions allows for the acceptance of an arbitrary number of positional arguments, providing flexibility in function calls, such as aggregating values or passing varying numbers of arguments to a function without explicitly defining each parameter. This facilitates use cases like summing an unknown quantity of numbers, for example, def add(*args): return sum(args). It allows developers to write generalized code that can handle diverse input scenarios, enhancing function versatility .

Global variables in Python can lead to programs that are hard to debug and maintain due to unintended side-effects across different parts of the code. They may be unintentionally modified from different scopes, complicating state management and increasing the potential for errors. Their usage can be minimized by using local variables within functions and classes, thereby encapsulating functionality and maintaining data within confined contexts. When necessary, global variables should be clearly documented and used with the global keyword within functions to avoid accidental shadowing .

Python handles errors using try-except blocks, which allow developers to catch exceptions and handle them gracefully without terminating the program. By using this mechanism, developers can specify what to do when an error occurs, like logging the error or retrying a block of code, thereby preventing crashes. This is important for robust program development because it enhances program stability and user experience, allowing the program to continue operations even when unexpected issues arise, such as handling a ZeroDivisionError during division .

Arithmetic operators in Python, such as + (addition), - (subtraction), * (multiplication), and / (division), are used to perform mathematical operations on numeric values. For example, they can be used in a calculation within a financial application. Logical operators, such as 'and', 'or', and 'not', are used to evaluate expressions based on boolean logic, determining the truth value of a condition. They are useful in control flow structures like 'if' statements to make decisions based on multiple conditions .

Encapsulation in Python is implemented through the definition of class and instance variables, along with access restrictions. Attributes can be defined as public, protected (with a single underscore), and private (with a double underscore), controlling the visibility outside the class. Encapsulation is fundamental in OOP because it restricts direct access to object data, ensuring data integrity and security while allowing controlled interaction through methods. This helps maintain the internal state of an object and allows changes without affecting external code that uses the class .

Positional arguments require that values be passed in the order defined by the function, which can lead to errors if not handled correctly . Keyword arguments specify the parameter name with the value, which enhances readability and avoids the order requirement. Default arguments allow a function to assume a default value for parameters if none are provided, providing flexibility and reducing the need to specify values frequently used . Together, these options provide flexibility in function calls, making them adaptable to different needs.

Python's comparison operators, such as ==, !=, >, <, >=, and <=, are essential in constructing conditional logic, allowing the evaluation of variable relationships to control program flow. They are commonly used in conditional statements like 'if' or loops to decide execution paths based on data conditions. Misusing these operators, such as using = instead of ==, can lead to logical errors, where the program does not behave as intended, and potentially introduce bugs that are difficult to trace in larger applications .

List comprehensions offer a more concise and readable way to create lists in Python. They allow for the integration of expressions and loops in a single line, which can make code shorter and easier to understand, such as creating a list of squares from a range of numbers . However, traditional for loops might still be preferable when complex logic needs to be applied, such as multiple nested conditions or complex data manipulation that would be cumbersome within a single line comprehension.

You might also like