RAMAKAYAL COMPUTER EDUCATION

Category: Python

File Handling in Python: Read, Write, and Manage Files
What is File Handling?

“File handling allows you to interact with files stored on your computer. You can create, read, write, and update files directly from your Python code.”

Example Use Cases:
1. Automating report generation.
2. Reading large datasets for analysis.
3. Logging activities in an application.
Modes of File Handling in Python

“When working with files, you can open them in different modes:
- r: Read mode
- w: Write mode
- a: Append mode
- r+: Read and write mode
- x: Create a file but throw an error if it already exists.”
Reading a File in Python

“Let’s start with reading files. Suppose you have a file named example.txt containing some data.”
```
with open("example.txt", "r") as file:  
    content = file.read()  
    print(content)  
```
“This reads the entire content of the file and prints it. The with statement ensures the file closes automatically.”

Writing to a File

“Now, let’s write data into a file. If the file doesn’t exist, Python creates it.”
```
with open("output.txt", "w") as file:  
    file.write("Hello, this is written by Python!")  
```
“This will overwrite the file if it already exists. Be cautious while using w mode.”

Appending Data to a File

“What if you don’t want to overwrite the file but instead add new data? Use append mode (a).”
```
with open("output.txt", "a") as file:  
    file.write("\nAdding a new line to the file.")  
```
Reading Files Line by Line
- “For large files, reading line by line saves memory.”
```
with open("example.txt", "r") as file:  
    for line in file:  
        print(line.strip())  
```
Examples :
1. A school generates a report for each student
```
students = ["Saravana", "Anjali", "Rahul"]  

with open("students_report.txt", "w") as report:  
    for student in students:  
        report.write(f"Report for {student}\n")  
        report.write("Maths: 85, Science: 90, English: 88\n\n")  
```
2. Create backups of important data by copying files.
```
def backup_file(source, destination):
    with open(source, "r") as src:
        data = src.read()
    with open(destination, "w") as dest:
        dest.write(data)

backup_file("important_data.txt", "backup_important_data.txt")
print("Backup created successfully!")
```
Use Case: Periodic backups for financial reports or user records.

Inventory Management in Retail
```
def update_inventory(item, quantity):
    with open("inventory.txt", "a") as inventory_file:
        inventory_file.write(f"{item}: {quantity}\n")

update_inventory("Laptop", 10)
update_inventory("Smartphone", 15)
print("Inventory updated!")
```
Use Case: Managing stock for e-commerce websites or retail stores.

Maintaining an Attendance Log
```
def mark_attendance(student_name, date):
    with open("attendance_log.txt", "a") as log:
        log.write(f"{student_name} attended on {date}\n")

mark_attendance("Saravana", "2024-11-20")
mark_attendance("Anjali", "2024-11-20")
print("Attendance marked!")
```
July 5, 2025
Python- Module 5 – Python Objects – Step-by-Step Guide for Beginners
In Python, everything is an object – yes, even numbers, strings, and functions!

Let’s understand what objects are, how they work, and how you can create your own.

🔹 Step 1: What is an Object?

An object is a collection of data (variables) and behaviors (functions/methods). Think of an object as a real-world thing that has:
- Properties (like name, color, age)
- Actions (like speak, walk, drive)
📌 Example: A Car is an object. It has properties like brand, model, color and actions like start(), stop(), drive().

🔹 Step 2: Objects Are Created from Classes

A class is like a blueprint. You use it to create objects.

📦 Class = Design
🚗 Object = Real item built from that design

🔹 Step 3: Define a Class in Python
```
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def greet(self):
        print(f"Hi, I am {self.name} and I am {self.age} years old.")
```
Explanation:
- class Person: → defines a new class called Person
- __init__() → a special method that runs when an object is created (like a constructor)
- self → refers to the current object
- greet() → a method (function inside the class)
Step 4: Create Objects from the Class
```
p1 = Person("Asha", 25)
p2 = Person("Ravi", 30)
```
```
p1.greet()  # Output: Hi, I am Asha and I am 25 years old.
p2.greet()  # Output: Hi, I am Ravi and I am 30 years old.
```
Now, p1 and p2 are objects (also called instances) of the class Person.

🔹 Step 5: Add More Methods

You can add more functions (called methods) inside the class:
```
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def greet(self):
        print(f"Hi, I am {self.name} and I am {self.age} years old.")
        
    def checkvote(self):
        if(self.age>=18):
            print("Eligible to Vote")
        else:
            print("Not Eligible to Vote")

a1=Person("Asha",10)
a1.greet()
a1.checkvote()
```
Concept Real Life Example
Class Mobile phone design
Object Real phone in your hand
Attribute Brand, model, price
Method Call, message, camera

Example :
```
class student:
    def __init__ (self,rollno,stname,m1,m2,m3,m4,m5):
        self.rollno=rollno
        self.stname=stname
        self.m1=m1
        self.m2=m2
        self.m3=m3
        self.m4=m4
        self.m5=m5

    def result(self):
        total=self.m1+self.m2+self.m3+self.m4+self.m5
        print("Total = ",total)

    def welcome(self):
        print("Welcome : ",self.stname)
        
s1=student(1001,'Raja',100,100,80,70,90)
s2=student(1002,'Kumar',100,100,80,100,90)
s1.welcome()
s1.result()
s2.welcome()
s2.result()
```
Output

Welcome : Raja
Total = 440
Welcome : Kumar
Total = 470
May 31, 2025
Python Module 4: Data Structures in Python – Complete Notes
🧠 What are Data Structures?

Data structures are ways to store and organize data so we can access and modify it efficiently.

🧱 Types of Built-in Data Structures in Python

Python has 4 main built-in data structures:

Type Ordered Mutable Allows Duplicates Syntax
List ✅ Yes ✅ Yes ✅ Yes []
Tuple ✅ Yes ❌ No ✅ Yes ()
Set ❌ No ✅ Yes ❌ No (unique) {}
Dictionary ✅ Yes ✅ Yes ❌ No (unique keys) {key: value}

1️⃣ Lists – Ordered and Mutable

Used to store multiple items in a single variable.

🔹 Syntax:
```
my_list = [10, 20, 30, "Python", True]
```
🔹 Operations
```
my_list[1]          # Access
my_list.append(40)  # Add at end
my_list.remove(20)  # Remove item
my_list[0] = 100    # Update item
```
2️⃣ Tuples – Ordered and Immutable

Like lists, but cannot be changed (read-only).

🔹 Syntax:
```
my_tuple = (10, 20, 30, "Python")
```
🔹 Operations
```
my_tuple[1]        # Access
len(my_tuple)      # Length
# Cannot add or remove elements
```
📌 Use when data should not be changed, like dates or constants.

3️⃣ Sets – Unordered, No Duplicates

Used to store unique values.

🔹 Syntax:
```
my_set = {1, 2, 3, 4, 4, 2}
print(my_set)  # Output: {1, 2, 3, 4}
```
🔹 Operations
```
my_set.add(5)        # Add item
my_set.remove(3)     # Remove item
```
✅ Good for membership tests and removing duplicates.

4️⃣ Dictionaries – Key-Value Pairs

Used to store data in pairs (like a real-life dictionary).

🔹 Syntax:
```
my_dict = {"name": "John", "age": 25, "is_student": True}
```
🔹 Operations
```
my_dict["name"]             # Access value
my_dict["age"] = 26         # Update value
my_dict["city"] = "Chennai" # Add new pair
del my_dict["is_student"]   # Delete key
```
🔁 Looping Through Data Structures

🔹 List/Tuple:
```
for item in my_list:
    print(item)
```
🔹 Set:
```
for item in my_set:
    print(item)
```
🔹 Dictionary:
```
for key, value in my_dict.items():
    print(key, value)


profile={"name":"kumar","age":20}
for key,value in profile.items():
    print(key,":",value)
```
Output:

name : kumar
age : 20

🧪 Example Practice:
```
students = ["Arun", "Beena", "Charles"]
print(students)
marks = (85, 90, 78)
print(marks)
unique_subjects = {"Math", "Science", "Math"}  
print(unique_subjects)
profile = {"name": "Kumar", "age": 20}
print(profile)
```
📌 Summary for Beginners:

Data Type Use for…
List Store changing sequences
Tuple Store fixed sequences
Set Store unique items
Dictionary Store labeled data (key-value)

real-life use cases with examples

✅ 1. List – When Order & Change Matters

📌 Real-Life Use Case:
- Shopping List – You add items, remove items, or change quantities.
🧪 Python Example:
```
shopping_list = ["milk", "eggs", "bread"]
shopping_list.append("butter")      # Add item
shopping_list.remove("milk")        # Remove item
shopping_list[0] = "cheese" 
# Replace "eggs" with "cheese"
print(shopping_list)  
# Output: ['cheese', 'bread', 'butter']
```
✅ Use When:
- You need ordered items.
- Items can change (mutable).
- Duplicates are okay.
✅ 2. Tuple – When Data Shouldn’t Change

📌 Real-Life Use Case:
- Date of Birth, GPS coordinates, or Configuration values – These don’t change.
```
date_of_birth = (1995, 12, 15)  # year, month, day
coordinates = (13.0827, 80.2707)  # Chennai GPS

print("Born in:", date_of_birth[0])
```
✅ Use When:
- You want a fixed collection of values.
- Memory efficiency is important.
- Used as dictionary keys (immutable).
✅ 3. Set – When You Need Only Unique Items

📌 Real-Life Use Case:
- Attendees List – To ensure no one is counted twice.
- Available tags or unique student IDs.
```
attendees = {"Alice", "Bob", "Alice", "David"}
print(attendees)  # Output: {'Alice', 'Bob', 'David'}

attendees.add("Eve")     # Add new person
attendees.remove("Bob")  # Remove person

print(attendees)
```
✅ Use When:
- Order doesn’t matter.
- No duplicates allowed.
- You want fast membership test (in operator).
✅ 4. Dictionary – Store Data with Labels

📌 Real-Life Use Case:
- Student Profile, Bank Account Details, Product Catalog
```
student = {
    "name": "Karthik",
    "age": 21,
    "marks": 88,
    "college": "ABC University"
}

# Accessing values
print(student["name"])   # Karthik
student["marks"] = 92    # Update marks
student["city"] = "Chennai"  # Add new key
print(student)
```
✅ Use When:
- You need to label values (name, age, etc.).
- Quick lookup based on key.
- You want structured data.
💡 Quick Analogy for Remembering:

Real Life Python Data Structure
Shopping list List
Birth certificate Tuple
Guest register book Set
Student ID card Dictionary

🔄 Mixed Example (All in One):
```
students = [
    {"name": "Arun", "age": 17, "subjects": {"Math", "Science"}},
    {"name": "Beena", "age": 18, "subjects": {"Math", "English"}},
]

for student in students:
    print(f"{student['name']} is {student['age']} years old and studies {student['subjects']}")
```
This uses:
- List of students
- Dictionaries to store each student’s details
- Sets to store unique subjects
May 28, 2025
Python-Module 3: Control Flow Statements in Python
🚦 What is Control Flow?

In real life, we make decisions all the time.
For example:
- If it’s raining, take an umbrella.
- If you finish your homework, then play.
Python does the same using control flow statements. These help the program decide what to do next.

✅ 1. if Statement

🧠 Use: To do something only if a condition is true.

📘 Syntax:
```
if condition:
    # do something
```
🧪 Example:
```
if 5 > 2:
    print("5 is greater than 2")
```
✅ 2. if...else Statement

🧠 Use: To choose between two options.

📘 Syntax:
```
if condition:
    # do this if true
else:
    # do this if false
```
🧪 Example:
```
age = 16
if age >= 18:
    print("You can vote")
else:
    print("You are too young to vote")
```
✅ 3. if…elif…else

🧠 Use: To check more than two conditions.

📘 Syntax:
```
if condition1:
    # do this
elif condition2:
    # do this
else:
    # do this if nothing above is true
```
🧪 Example:
```
score = 85
if score >= 90:
    print("Grade A")
elif score >= 80:
    print("Grade B")
else:
    print("Try harder")
```
🔁 4. while Loop

🧠 Use: To repeat as long as the condition is true.

📘 Syntax:
```
while condition:
    # do this again and again
```
🧪 Example:
```
count = 1
while count <= 3:
    print("Count is", count)
    count += 1
```
🔁 5. for Loop

🧠 Use: To loop through a list, string, or range.

📘 Syntax:
```
for item in list:
    # do this for each item
```
🧪 Example:
```
for i in range(1, 4):
    print("Number:", i)
```
⛔ 6. break Statement

🧠 Use: To stop a loop early.

📘 Syntax:
```
for i in range(5):
    if i == 3:
        break
    print(i)
```
🧪 Output
```
0
1
2
```
🔄 7. continue Statement

🧠 Use: To skip one step and move to the next.

📘 Syntax:
```
for i in range(5):
    if i == 3:
        continue
    print(i)
```
🧪 Output
```
0
1
2
4
```
May 16, 2025
Python Module 2 (Operators and Expressions)
In this lesson, we will learn about Operators and Expressions in Python.

✨ Types of Operators in Python

1. Arithmetic Operators

These are used for basic math:

Operator Description Example (a = 10, b = 3) Result
+ Addition a + b 13
- Subtraction a - b 7
* Multiplication a * b 30
/ Division a / b 3.33
// Floor Division a // b 3
% Modulus (remainder) a % b 1
** Exponentiation a ** b 1000

📌 Try this in Python:
```
print(5 + 3)
print(7 % 2)
print(2 ** 3)
```
2. Comparison (Relational) Operators

Compare values and return True or False.

Operator Description Example (a = 10, b = 3) Result
== Equal to a == b False
!= Not equal to a != b True
> Greater than a > b True
< Less than a < b False
>= Greater than or equal a >= b True
<= Less than or equal a <= b False

3. Logical Operators

Used to combine conditional statements.

Operator Description Example Result
and True if both are true True and False False
or True if at least one is true True or False True
not Reverses result not True False

4. Assignment Operators

Assign values to variables.

Operator Example Same As
= x = 5 Assign 5 to x
+= x += 3 x = x + 3
-= x -= 2 x = x - 2
*= x *= 4 x = x * 4
/= x /= 2 x = x / 2
//= x //= 2 x = x // 2
%= x %= 2 x = x % 2
**= x **= 3 x = x ** 3

5.Bitwise Operators

Bitwise operators work on bits (0s and 1s) of integers at the binary level.

They are used to perform operations like AND, OR, XOR, NOT, etc., bit-by-bit.

Operator Description Example
& AND 5 & 3 = 1
` ` OR
^ XOR 5 ^ 3 = 6
~ NOT ~5 = -6
<< Left Shift 5 << 1 = 10
>> Right Shift 5 >> 1 = 2

🧪 6. Identity and Membership Operators

Identity :
```
x = [1, 2]
y = x
print(x is y)  # True
```
Membership
```
fruits = ["apple", "banana"]
print("apple" in fruits)  # True
```
Expressions in Python

x = 10
y = 5
result = (x + y) * 2
print(result) # Output: 30

Operator Precedence

Determines the order in which operations are performed.

From highest to lowest:
1. () – Parentheses
2. ** – Exponentiation
3. +, - (Unary)
4. *, /, //, %
5. +, - (Binary)
6. <, <=, >, >=, ==, !=
7. and
8. or
9. =, +=, -=, etc.
Example :
```
x = 10
y = 4
z = 3

result = x + y * z - y / 2
print(result)
# Output: 10 + 12 - 2.0 = 20.0
```
Examples

🔢 1. Arithmetic Operators
```
a = 10
b = 3

print(a + b)   # Output: 13
print(a - b)   # Output: 7
print(a * b)   # Output: 30
print(a / b)   # Output: 3.333...
print(a // b)  # Output: 3
print(a % b)   # Output: 1
print(a ** b)  # Output: 1000
```
🤝 2. Comparison Operators
```
x = 5
y = 10

print(x == y)  # Output: False
print(x != y)  # Output: True
print(x > y)   # Output: False
print(x < y)   # Output: True
print(x >= 5)  # Output: True
print(y <= 10) # Output: True
```
🧠 3. Logical Operators
```
a = True
b = False

print(a and b)  # Output: False
print(a or b)   # Output: True
print(not a)    # Output: False
```
🧱 4. Bitwise Operators
```
a = 5      # 0101
b = 3      # 0011

print(a & b)  # Output: 1  (0001)
print(a | b)  # Output: 7  (0111)
print(a ^ b)  # Output: 6  (0110)
print(~a)     # Output: -6 (inverts bits)
print(a << 1) # Output: 10 (shifts left: 1010)
print(a >> 1) # Output: 2  (shifts right: 0010)
```
✍️ 5. Assignment Operators
```
x = 5
x += 3     # Same as x = x + 3
print(x)   # Output: 8

x *= 2     # x = x * 2
print(x)   # Output: 16
```
🔍 6. Identity Operators
```
a = [1, 2]
b = a
c = [1, 2]

print(a is b)  # Output: True
print(a is c)  # Output: False
print(a == c)  # Output: True (values are same)
```
🍎 7. Membership Operators
```
fruits = ["apple", "banana", "cherry"]

print("banana" in fruits)   # Output: True
print("grape" not in fruits)  # Output: True
```
🎯 8. Expressions Example
```
result = (5 + 3) * 2 - 4 / 2
print(result)  # Output: 14.0
```
Welcome to the Python Programming Quiz!

Test your knowledge by selecting the correct answers. You will immediately see if you’re right or wrong.

Score: 0
May 16, 2025