Python vs Java: Side-by-Side Programming

Tutorial
A Comprehensive Educational Presentation

Slide 1: Introduction to Python and Java

Welcome to Dual Programming Language Learning!

Today's Objectives:

Understand key differences between Python and Java

Learn fundamental programming concepts in both languages

Compare syntax and programming approaches

Build practical coding skills simultaneously

Why Learn Both Languages?

Python: Easy to learn, powerful for data science, AI, and rapid development
Java: Industry standard, object-oriented, platform independent
Together: Comprehensive foundation for any programming career

Slide 2: Language Overview Comparison

Aspect Python Java

Type System Dynamic typing Static typing

Syntax Style Indentation-based Bracket-based

Compilation Interpreted Compiled to bytecode

Learning Curve Beginner-friendly Moderate complexity

Performance Slower execution Faster execution

Use Cases Data science, scripting, web Enterprise apps, Android

File Extension .py .java

Slide 3: Hello World - First Programs

Python Hello World

# Simple and straightforward

print("Hello, World!")
print("Welcome to Python programming!")

# Interactive greeting
name = input("What's your name? ")
print(f"Hello, {name}!")

Java Hello World

// More structured approach

public class HelloWorld {
public static void main(String[] args) {
[Link]("Hello, World!");
[Link]("Welcome to Java programming!");

// Interactive greeting requires Scanner

[Link] scanner = new [Link]([Link]);
[Link]("What's your name? ");
String name = [Link]();
[Link]("Hello, " + name + "!");
[Link]();
}
}

Key Differences:

Python: Direct execution, no boilerplate code

Java: Requires class structure and main method

Slide 4: Variables and Data Types

Python Variables (Dynamic Typing)

# Variables can change types freely

name = "Alice" # String
age = 25 # Integer
height = 5.6 # Float (double precision)
is_student = True # Boolean
grades = [95, 87, 92] # List (dynamic array)
student_info = {} # Dictionary (key-value pairs)

# Type can change during runtime

score = 100 # Initially integer
score = "Excellent" # Now string - perfectly valid!
 # Check type
print(type(name)) # <class 'str'>
print(type(age)) # <class 'int'>

Java Variables (Static Typing)

// Variables must be declared with specific types

String name = "Alice"; // String
int age = 25; // Integer
double height = 5.6; // Double precision float
boolean isStudent = true; // Boolean
int[] grades = {95, 87, 92}; // Array of integers
Map<String, Object> studentInfo = new HashMap<>(); // Map

// Type cannot change after declaration

int score = 100; // Integer
// score = "Excellent"; // COMPILE ERROR!

// Type checking at compile time

[Link]([Link]()); // class [Link]

Key Differences:

Python: No type declaration needed, flexible but runtime errors possible

Java: Explicit type declaration, catch errors at compile time

Slide 5: Basic Operations and String Handling

Python Operations

# Arithmetic operations
a = 10
b = 3
print(f"Addition: {a + b}") # 13
print(f"Division: {a / b}") # 3.3333...
print(f"Integer Division: {a // b}") # 3
print(f"Power: {a ** b}") # 1000

# String operations
first_name = "John"
last_name = "Doe"
full_name = first_name + " " + last_name
print(f"Hello, {full_name}!") # f-string formatting
print("Hello, {}!".format(full_name)) # .format() method
print("Hello, %s!" % full_name) # % formatting

# String methods
text = "Python Programming"
print([Link]()) # python programming
 print([Link]()) # ['Python', 'Programming']
print(len(text)) # 18

Java Operations

// Arithmetic operations
int a = 10;
int b = 3;
[Link]("Addition: " + (a + b)); // 13
[Link]("Division: " + ((double)a / b)); // 3.3333...
[Link]("Integer Division: " + (a / b)); // 3
[Link]("Power: " + [Link](a, b)); // 1000.0

// String operations
String firstName = "John";
String lastName = "Doe";
String fullName = firstName + " " + lastName;
[Link]("Hello, " + fullName + "!");
[Link]("Hello, %s!%n", fullName); // printf formatting
String formatted = [Link]("Hello, %s!", fullName);

// String methods
String text = "Java Programming";
[Link]([Link]()); // java programming
[Link]([Link]([Link](" "))); // [Java, Programming]
[Link]([Link]()); // 16

Slide 6: Conditional Statements

Python Conditionals

# Basic if-elif-else structure

age = 18
grade = 85

if age < 13:

category = "Child"
elif age < 20:
category = "Teenager"
else:
category = "Adult"

# Multiple conditions
if age >= 18 and grade >= 80:
print("Eligible for honors program")
elif age >= 18 or grade >= 90:
print("Eligible for regular program")
else:
print("Not eligible")

# Compact conditional (ternary operator)

 status = "Pass" if grade >= 60 else "Fail"
print(f"Result: {status}")

# Checking membership
subjects = ["Math", "Physics", "Chemistry"]
if "Physics" in subjects:
print("Physics is included!")

Java Conditionals

// Basic if-else if-else structure

int age = 18;
int grade = 85;
String category;

if (age < 13) {

category = "Child";
} else if (age < 20) {
category = "Teenager";
} else {
category = "Adult";
}

// Multiple conditions
if (age >= 18 && grade >= 80) {
[Link]("Eligible for honors program");
} else if (age >= 18 || grade >= 90) {
[Link]("Eligible for regular program");
} else {
[Link]("Not eligible");
}

// Ternary operator
String status = (grade >= 60) ? "Pass" : "Fail";
[Link]("Result: " + status);

// Switch statement (Java-specific)

switch (category) {
case "Child":
[Link]("Requires guardian");
break;
case "Teenager":
[Link]("Limited privileges");
break;
default:
[Link]("Full privileges");
}

Key Differences:

Python: Uses elif, natural language operators (and, or, in)

Java: Uses else if, symbolic operators (&&, ||), has switch statements
Slide 7: Loops - Iteration Structures

Python Loops

# For loop with range

print("Counting with range:")
for i in range(5): # 0 to 4
print(f"Count: {i}")

for i in range(1, 6): # 1 to 5

print(f"Number: {i}")

for i in range(0, 10, 2): # 0, 2, 4, 6, 8

print(f"Even: {i}")

# For loop with collections

fruits = ["apple", "banana", "orange", "grape"]
for fruit in fruits:
print(f"I like {fruit}")

# Enumerate for index and value

for index, fruit in enumerate(fruits):
print(f"{index}: {fruit}")

# While loop
count = 0
while count < 3:
print(f"While count: {count}")
count += 1

# List comprehension (Python-specific)

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

Java Loops

// Traditional for loop

[Link]("Counting with traditional for:");
for (int i = 0; i < 5; i++) { // 0 to 4
[Link]("Count: " + i);
}

for (int i = 1; i <= 5; i++) { // 1 to 5

[Link]("Number: " + i);
}

for (int i = 0; i < 10; i += 2) { // 0, 2, 4, 6, 8

[Link]("Even: " + i);
}

// Enhanced for loop (for-each)

String[] fruits = {"apple", "banana", "orange", "grape"};
for (String fruit : fruits) {
 [Link]("I like " + fruit);
}

// Manual index tracking

for (int i = 0; i < [Link]; i++) {
[Link](i + ": " + fruits[i]);
}

// While loop
int count = 0;
while (count < 3) {
[Link]("While count: " + count);
count++;
}

// Creating arrays with loops

int[] squares = new int[5];
for (int i = 0; i < 5; i++) {
squares[i] = i * i; // [0, 1, 4, 9, 16]
}

Key Differences:

Python: More intuitive iteration, built-in range(), list comprehensions

Java: More explicit syntax, traditional C-style loops, enhanced for-each loops

Slide 8: Functions vs Methods

Python Functions

# Basic function definition

def greet(name):
"""Function to greet a person"""
return f"Hello, {name}!"

# Function with default parameters

def calculate_area(length, width=1):
"""Calculate rectangle area with optional width"""
return length * width

# Function with multiple return values

def get_name_parts(full_name):
"""Split name into first and last"""
parts = full_name.split()
first = parts[0]
last = parts[-1] if len(parts) > 1 else ""
return first, last

# Function with variable arguments

def calculate_average(*numbers):
"""Calculate average of any number of values"""
if not numbers:
 return 0
return sum(numbers) / len(numbers)

# Function with keyword arguments

def create_student(name, age, **details):
"""Create student with additional details"""
student = {"name": name, "age": age}
[Link](details)
return student

# Function calls and usage

message = greet("Alice")
area1 = calculate_area(5, 3) # 15
area2 = calculate_area(4) # 4 (default width)
first, last = get_name_parts("John Doe")
avg = calculate_average(90, 85, 92, 88)
student = create_student("Bob", 20, major="CS", gpa=3.8)

Java Methods

public class StudentUtils {

// Basic method definition

public static String greet(String name) {
return "Hello, " + name + "!";
}

// Method overloading for default parameters

public static double calculateArea(double length, double width) {
return length * width;
}

public static double calculateArea(double length) {

return calculateArea(length, 1.0); // default width
}

// Method returning multiple values using array

public static String[] getNameParts(String fullName) {
String[] parts = [Link](" ");
String first = parts[0];
String last = [Link] > 1 ? parts[[Link] - 1] : "";
return new String[]{first, last};
}

// Method with variable arguments (varargs)

public static double calculateAverage(double... numbers) {
if ([Link] == 0) return 0.0;
double sum = 0;
for (double num : numbers) {
sum += num;
}
return sum / [Link];
}

// Method using Map for flexible parameters

 public static Map<String, Object> createStudent(String name, int age,
Map<String, Object> details) {
Map<String, Object> student = new HashMap<>();
[Link]("name", name);
[Link]("age", age);
if (details != null) {
[Link](details);
}
return student;
}

// Main method demonstrating usage

public static void main(String[] args) {
String message = greet("Alice");
double area1 = calculateArea(5.0, 3.0); // 15.0
double area2 = calculateArea(4.0); // 4.0
String[] names = getNameParts("John Doe");
double avg = calculateAverage(90, 85, 92, 88);

Map<String, Object> details = new HashMap<>();

[Link]("major", "CS");
[Link]("gpa", 3.8);
Map<String, Object> student = createStudent("Bob", 20, details);
}
}

Key Differences:

Python: Simple def keyword, flexible parameter handling, multiple return values
Java: Method overloading for defaults, more verbose syntax, static methods for utility functions

Slide 9: Data Structures - Arrays and Lists

Python Lists and Collections

# Lists (dynamic arrays)

numbers = [1, 2, 3, 4, 5]
mixed_list = [1, "hello", 3.14, True] # Can hold different types

# List operations
[Link](6) # Add to end
[Link](0, 0) # Insert at index
[Link](3) # Remove first occurrence
popped = [Link]() # Remove and return last
[Link]([7, 8, 9]) # Add multiple elements

print(f"Length: {len(numbers)}")
print(f"First element: {numbers[0]}")
print(f"Last element: {numbers[-1]}")
print(f"Slice [1:4]: {numbers[1:4]}")

# List methods
 numbers_copy = [Link]()
[Link]()
[Link]()
index_of_5 = [Link](5)
count_of_1 = [Link](1)

# Other collections
student_set = {"Alice", "Bob", "Charlie"} # Set (unique elements)
student_dict = {"Alice": 90, "Bob": 85} # Dictionary
coordinates = (10, 20) # Tuple (immutable)

# List comprehensions
squares = [x**2 for x in range(1, 6)] # [1, 4, 9, 16, 25]
even_nums = [x for x in range(10) if x % 2 == 0] # [0, 2, 4, 6, 8]

Java Arrays and Collections

import [Link].*;

public class DataStructures {

public static void main(String[] args) {
// Arrays (fixed size)
int[] numbers = {1, 2, 3, 4, 5};
String[] names = new String[3]; // Fixed size array
names[0] = "Alice";
names[1] = "Bob";
names[2] = "Charlie";

// Array operations
[Link]("Length: " + [Link]);
[Link]("First element: " + numbers[0]);
[Link]("Last element: " + numbers[[Link] - 1]);

// Arrays utility methods

int[] numbersCopy = [Link](numbers, [Link]);
[Link](numbers);
int index = [Link](numbers, 3);
[Link]("Array as string: " + [Link](numbers));

// Dynamic collections
ArrayList<Integer> numberList = new ArrayList<>();
[Link](1);
[Link](2);
[Link](3);
[Link](0, 0); // Insert at index
[Link]([Link](2)); // Remove by value
int removed = [Link]([Link]() - 1); // Remove last

[Link]("Size: " + [Link]());

[Link]("Contains 3: " + [Link](3));
[Link]("Index of 1: " + [Link](1));

// Other collections
Set<String> studentSet = new HashSet<>();
[Link]("Alice");
 [Link]("Bob");

Map<String, Integer> studentGrades = new HashMap<>();

[Link]("Alice", 90);
[Link]("Bob", 85);

// Creating lists with streams (Java 8+)

List<Integer> squares = [Link](1, 6)
.map(x -> x * x)
.boxed()
.collect([Link]());
}
}

Key Differences:

Python: Dynamic lists, mixed types allowed, simple syntax, powerful comprehensions

Java: Fixed arrays + dynamic collections, type-safe, more verbose, streams for functional
operations

Slide 10: Object-Oriented Programming - Classes

Python Classes

class Student:
# Class variable (shared by all instances)
total_students = 0

def __init__(self, name, age, student_id):

"""Constructor method"""
[Link] = name # Instance variables
[Link] = age
self.student_id = student_id
[Link] = []
self.enrolled_courses = []
Student.total_students += 1

def add_grade(self, subject, grade):

"""Add a grade for a subject"""
[Link]({"subject": subject, "grade": grade})

def get_average_grade(self):
"""Calculate average grade"""
if not [Link]:
return 0
total = sum(grade_info["grade"] for grade_info in [Link])
return total / len([Link])

def enroll_course(self, course):

"""Enroll in a course"""
if course not in self.enrolled_courses:
self.enrolled_courses.append(course)
 def display_info(self):
"""Display student information"""
avg = self.get_average_grade()
courses = ", ".join(self.enrolled_courses)
return f"Student: {[Link]} (ID: {self.student_id})\n" \
f"Age: {[Link]}, Average Grade: {avg:.1f}\n" \
f"Courses: {courses}"

@classmethod
def get_total_students(cls):
"""Class method to get total students"""
return cls.total_students

@staticmethod
def is_passing_grade(grade):
"""Static method to check if grade is passing"""
return grade >= 60

def __str__(self):
"""String representation"""
return f"Student({[Link]}, {[Link]})"

def __repr__(self):
"""Official string representation"""
return f"Student(name='{[Link]}', age={[Link]}, id='{self.student_id}')"

# Usage
student1 = Student("Alice", 20, "S001")
student2 = Student("Bob", 19, "S002")

student1.add_grade("Math", 95)
student1.add_grade("Physics", 87)
student1.enroll_course("Computer Science")
student1.enroll_course("Mathematics")

print(student1.display_info())
print(f"Total students: {Student.get_total_students()}")
print(f"Is 75 passing? {Student.is_passing_grade(75)}")

Java Classes

import [Link].*;

public class Student {

// Class variable (static)
private static int totalStudents = 0;

// Instance variables (private for encapsulation)

private String name;
private int age;
private String studentId;
private List<GradeInfo> grades;
private List<String> enrolledCourses;
// Inner class for grade information
private static class GradeInfo {
String subject;
int grade;

GradeInfo(String subject, int grade) {

[Link] = subject;
[Link] = grade;
}
}

// Constructor
public Student(String name, int age, String studentId) {
[Link] = name;
[Link] = age;
[Link] = studentId;
[Link] = new ArrayList<>();
[Link] = new ArrayList<>();
totalStudents++;
}

// Public methods (getters and setters)

public String getName() { return name; }
public int getAge() { return age; }
public String getStudentId() { return studentId; }

public void setName(String name) { [Link] = name; }

public void setAge(int age) { [Link] = age; }

// Method to add grade

public void addGrade(String subject, int grade) {
[Link](new GradeInfo(subject, grade));
}

// Method to calculate average grade

public double getAverageGrade() {
if ([Link]()) return 0.0;
int total = 0;
for (GradeInfo gradeInfo : grades) {
total += [Link];
}
return (double) total / [Link]();
}

// Method to enroll in course

public void enrollCourse(String course) {
if () {
[Link](course);
}
}

// Method to display information

public String displayInfo() {
double avg = getAverageGrade();
String courses = [Link](", ", enrolledCourses);
return [Link]("Student: %s (ID: %s)\nAge: %d, Average Grade: %.1f\nCourses
 name, studentId, age, avg, courses);
}

// Static method to get total students

public static int getTotalStudents() {
return totalStudents;
}

// Static method to check passing grade

public static boolean isPassingGrade(int grade) {
return grade >= 60;
}

// Override toString method

@Override
public String toString() {
return [Link]("Student(%s, %d)", name, age);
}

// Main method for testing

public static void main(String[] args) {
Student student1 = new Student("Alice", 20, "S001");
Student student2 = new Student("Bob", 19, "S002");

[Link]("Math", 95);
[Link]("Physics", 87);
[Link]("Computer Science");
[Link]("Mathematics");

[Link]([Link]());
[Link]("Total students: " + [Link]());
[Link]("Is 75 passing? " + [Link](75));
}
}

Key Differences:

Python: Simple class syntax, __init__ constructor, self parameter, dynamic attributes
Java: More verbose, explicit access modifiers, getter/setter methods, strict encapsulation

Slide 11: Error Handling and Debugging

Python Exception Handling

import traceback

def divide_numbers(a, b):

"""Function demonstrating exception handling"""
try:
result = a / b
return f"Result: {result}"
except ZeroDivisionError:
 return "Error: Cannot divide by zero!"
except TypeError as e:
return f"Error: Invalid data types - {e}"
except Exception as e:
return f"Unexpected error: {e}"
finally:
print("Division operation completed")

def read_file_safely(filename):
"""Safe file reading with exception handling"""
try:
with open(filename, 'r') as file:
content = [Link]()
return content
except FileNotFoundError:
print(f"Error: File '{filename}' not found")
return None
except PermissionError:
print(f"Error: Permission denied to read '{filename}'")
return None
except Exception as e:
print(f"Error reading file: {e}")
return None

def validate_student_data(name, age, grade):

"""Function with custom exception raising"""
if not isinstance(name, str) or len([Link]()) == 0:
raise ValueError("Name must be a non-empty string")

if not isinstance(age, int) or age < 0 or age > 150:

raise ValueError("Age must be a positive integer less than 150")

if not isinstance(grade, (int, float)) or grade < 0 or grade > 100:

raise ValueError("Grade must be a number between 0 and 100")

return {"name": name, "age": age, "grade": grade}

# Testing exception handling

print(divide_numbers(10, 2)) # Result: 5.0
print(divide_numbers(10, 0)) # Error: Cannot divide by zero!
print(divide_numbers("10", 2)) # Error: Invalid data types

# Testing custom exceptions

try:
student = validate_student_data("Alice", 20, 95)
print(f"Valid student: {student}")

invalid_student = validate_student_data("", -5, 150)

except ValueError as e:
print(f"Validation error: {e}")
traceback.print_exc() # Print full stack trace
Java Exception Handling

import [Link].*;
import [Link];

public class ErrorHandling {

// Method demonstrating exception handling

public static String divideNumbers(double a, double b) {
try {
double result = a / b;
return "Result: " + result;
} catch (ArithmeticException e) {
return "Error: " + [Link]();
} catch (Exception e) {
return "Unexpected error: " + [Link]();
} finally {
[Link]("Division operation completed");
}
}

// Safe file reading with exception handling

public static String readFileSafely(String filename) {
StringBuilder content = new StringBuilder();
try (BufferedReader reader = new BufferedReader(new FileReader(filename))) {
String line;
while ((line = [Link]()) != null) {
[Link](line).append("\n");
}
return [Link]();
} catch (FileNotFoundException e) {
[Link]("Error: File '" + filename + "' not found");
return null;
} catch (IOException e) {
[Link]("Error reading file: " + [Link]());
return null;
}
}

// Custom exception class

public static class ValidationException extends Exception {
public ValidationException(String message) {
super(message);
}
}

// Method with custom exception throwing

public static StudentData validateStudentData(String name, int age, double grade)
throws ValidationException {
if (name == null || [Link]().isEmpty()) {
throw new ValidationException("Name must be a non-empty string");
}

if (age < 0 || age > 150) {

throw new ValidationException("Age must be a positive integer less than 150")
}
 if (grade < 0 || grade > 100) {
throw new ValidationException("Grade must be between 0 and 100");
}

return new StudentData(name, age, grade);

}

// Simple data class

public static class StudentData {
String name;
int age;
double grade;

StudentData(String name, int age, double grade) {

[Link] = name;
[Link] = age;
[Link] = grade;
}

@Override
public String toString() {
return [Link]("Student{name='%s', age=%d, grade=%.1f}", name, age, gra
}
}

public static void main(String[] args) {

// Testing exception handling
[Link](divideNumbers(10.0, 2.0)); // Result: 5.0
[Link](divideNumbers(10.0, 0.0)); // Result: Infinity (no exception

// Testing custom exceptions

try {
StudentData student = validateStudentData("Alice", 20, 95.0);
[Link]("Valid student: " + student);

StudentData invalidStudent = validateStudentData("", -5, 150.0);

} catch (ValidationException e) {
[Link]("Validation error: " + [Link]());
[Link](); // Print stack trace
}
}
}

Key Differences:

Python: try/except/finally, built-in exception types, raise keyword

Java: try/catch/finally, checked vs unchecked exceptions, throw/throws keywords

Slide 12: File Handling and Input/Output

Python File Operations

import os
import json
import csv

# Writing to files
def write_text_file():
"""Demonstrate text file writing"""
# Method 1: Basic file writing
with open("student_info.txt", "w") as file:
[Link]("Student Information\n")
[Link]("==================\n")
[Link]("Name: Alice Johnson\n")
[Link]("Age: 20\n")
[Link]("Major: Computer Science\n")

# Method 2: Writing lists

students = ["Alice", "Bob", "Charlie", "Diana"]
with open("student_list.txt", "w") as file:
for student in students:
[Link](f"{student}\n")

def read_text_file():
"""Demonstrate text file reading"""
# Read entire file
try:
with open("student_info.txt", "r") as file:
content = [Link]()
print("Full content:")
print(content)
except FileNotFoundError:
print("File not found!")

# Read line by line

try:
with open("student_list.txt", "r") as file:
print("Students:")
for line_num, line in enumerate(file, 1):
print(f"{line_num}. {[Link]()}")
except FileNotFoundError:
print("Student list file not found!")

# Working with JSON

def json_operations():
"""Demonstrate JSON file operations"""
# Sample data
student_data = {
"students": [
{"name": "Alice", "age": 20, "grades": [95, 87, 92]},
{"name": "Bob", "age": 19, "grades": [88, 91, 85]},
{"name": "Charlie", "age": 21, "grades": [92, 89, 94]}
]
 }

# Write JSON
with open("[Link]", "w") as file:
[Link](student_data, file, indent=2)

# Read JSON
with open("[Link]", "r") as file:
loaded_data = [Link](file)
print("Loaded student data:")
for student in loaded_data["students"]:
avg = sum(student["grades"]) / len(student["grades"])
print(f"{student['name']}: Average = {avg:.1f}")

# Working with CSV

def csv_operations():
"""Demonstrate CSV file operations"""
# Write CSV
student_records = [
["Name", "Age", "Major", "GPA"],
["Alice", "20", "Computer Science", "3.8"],
["Bob", "19", "Mathematics", "3.6"],
["Charlie", "21", "Physics", "3.9"]
]

with open("[Link]", "w", newline="") as file:

writer = [Link](file)
[Link](student_records)

# Read CSV
with open("[Link]", "r") as file:
reader = [Link](file)
print("CSV Data:")
for row in reader:
print(" | ".join(row))

# User input
def get_user_input():
"""Demonstrate user input handling"""
try:
name = input("Enter your name: ")
age = int(input("Enter your age: "))
gpa = float(input("Enter your GPA: "))

print(f"Hello {name}! You are {age} years old with a GPA of {gpa:.2f}")

# Save to file
user_data = {"name": name, "age": age, "gpa": gpa}
with open("user_data.json", "w") as file:
[Link](user_data, file, indent=2)

except ValueError as e:
print(f"Invalid input: {e}")

# File and directory operations

def file_operations():
 """Demonstrate file system operations"""
# Check if file exists
if [Link]("[Link]"):
print("[Link] exists")
file_size = [Link]("[Link]")
print(f"File size: {file_size} bytes")

# List files in directory

print("Files in current directory:")
for filename in [Link]("."):
if [Link](filename):
print(f" File: {filename}")
elif [Link](filename):
print(f" Directory: {filename}")

# Create directory
if not [Link]("data"):
[Link]("data")
print("Created 'data' directory")

# Run demonstrations
if __name__ == "__main__":
write_text_file()
read_text_file()
json_operations()
csv_operations()
file_operations()

Java File Operations

import [Link].*;
import [Link].*;
import [Link].*;
import [Link]; // For JSON (external library)

public class FileHandling {

// Writing to files
public static void writeTextFile() throws IOException {
// Method 1: Using FileWriter
try (FileWriter writer = new FileWriter("student_info.txt")) {
[Link]("Student Information\n");
[Link]("==================\n");
[Link]("Name: Alice Johnson\n");
[Link]("Age: 20\n");
[Link]("Major: Computer Science\n");
}

// Method 2: Using [Link] (Java 8+)

List<String> students = [Link]("Alice", "Bob", "Charlie", "Diana");
[Link]([Link]("student_list.txt"), students);
}

public static void readTextFile() {

// Read entire file
 try {
String content = [Link]([Link]("student_info.txt"));
[Link]("Full content:");
[Link](content);
} catch (IOException e) {
[Link]("Error reading file: " + [Link]());
}

// Read line by line

try {
List<String> lines = [Link]([Link]("student_list.txt"));
[Link]("Students:");
for (int i = 0; i < [Link](); i++) {
[Link]((i + 1) + ". " + [Link](i));
}
} catch (IOException e) {
[Link]("Error reading student list: " + [Link]());
}
}

// Working with properties files (Java-style configuration)

public static void propertiesOperations() {
Properties props = new Properties();

// Write properties
[Link]("[Link]", "Tech University");
[Link]("semester", "Fall 2024");
[Link]("[Link]", "1250");

try (FileOutputStream out = new FileOutputStream("[Link]")) {

[Link](out, "School Configuration");
} catch (IOException e) {
[Link]("Error writing properties: " + [Link]());
}

// Read properties
Properties loadedProps = new Properties();
try (FileInputStream in = new FileInputStream("[Link]")) {
[Link](in);
[Link]("School: " + [Link]("[Link]"));
[Link]("Semester: " + [Link]("semester"));
[Link]("Students: " + [Link]("[Link]"));
} catch (IOException e) {
[Link]("Error reading properties: " + [Link]());
}
}

// CSV Operations
public static void csvOperations() {
// Write CSV
String[] header = {"Name", "Age", "Major", "GPA"};
String[][] records = {
{"Alice", "20", "Computer Science", "3.8"},
{"Bob", "19", "Mathematics", "3.6"},
{"Charlie", "21", "Physics", "3.9"}
};
 try (PrintWriter writer = new PrintWriter("[Link]")) {
// Write header
[Link]([Link](",", header));

// Write records
for (String[] record : records) {
[Link]([Link](",", record));
}
} catch (IOException e) {
[Link]("Error writing CSV: " + [Link]());
}

// Read CSV
try (Scanner scanner = new Scanner(new File("[Link]"))) {
[Link]("CSV Data:");
while ([Link]()) {
String line = [Link]();
String[] fields = [Link](",");
[Link]([Link](" | ", fields));
}
} catch (IOException e) {
[Link]("Error reading CSV: " + [Link]());
}
}

// User input
public static void getUserInput() {
Scanner scanner = new Scanner([Link]);

try {
[Link]("Enter your name: ");
String name = [Link]();

[Link]("Enter your age: ");

int age = [Link]();

[Link]("Enter your GPA: ");

double gpa = [Link]();

[Link]("Hello %s! You are %d years old with a GPA of %.2f%n",

name, age, gpa);

// Save to properties file

Properties userData = new Properties();
[Link]("name", name);
[Link]("age", [Link](age));
[Link]("gpa", [Link](gpa));

try (FileOutputStream out = new FileOutputStream("user_data.properties")) {

[Link](out, "User Data");
}

} catch (InputMismatchException e) {
[Link]("Invalid input format!");
} catch (IOException e) {
 [Link]("Error saving user data: " + [Link]());
}
}

// File and directory operations

public static void fileOperations() {
// Check if file exists
Path studentFile = [Link]("[Link]");
if ([Link](studentFile)) {
[Link]("[Link] exists");
try {
long fileSize = [Link](studentFile);
[Link]("File size: " + fileSize + " bytes");
} catch (IOException e) {
[Link]("Error getting file size: " + [Link]());
}
}

// List files in directory

[Link]("Files in current directory:");
try {
[Link]([Link]("."))
.forEach(path -> {
if ([Link](path)) {
[Link](" File: " + [Link]());
} else if ([Link](path)) {
[Link](" Directory: " + [Link]());
}
});
} catch (IOException e) {
[Link]("Error listing directory: " + [Link]());
}

// Create directory
Path dataDir = [Link]("data");
if () {
try {
[Link](dataDir);
[Link]("Created 'data' directory");
} catch (IOException e) {
[Link]("Error creating directory: " + [Link]());
}
}
}

public static void main(String[] args) {

try {
writeTextFile();
readTextFile();
propertiesOperations();
csvOperations();
fileOperations();
} catch (IOException e) {
[Link]("File operation error: " + [Link]());
}
 }
}

Key Differences:

Python: with statement for automatic file closing, built-in JSON support, simple CSV handling
Java: Try-with-resources, Properties files, more verbose but explicit resource management

Slide 13: Summary and Best Practices

Key Language Differences Summary

Feature Python Java

Syntax Style Clean, readable, indentation-based Verbose, explicit, bracket-based

Type System Dynamic, duck typing Static, strong typing

Memory Management Automatic garbage collection Automatic garbage collection

Performance Interpreted, slower execution Compiled bytecode, faster

Learning Curve Gentle, beginner-friendly Steeper, more concepts upfront

Code Length Typically shorter, more concise Longer, more boilerplate

Error Detection Runtime errors possible Compile-time error catching

Platform Independence Yes (with interpreter) Yes (JVM)

When to Choose Each Language

Choose Python When:

Learning programming for the first time

Building prototypes quickly

Working with data science and analytics

Creating automation scripts

Developing web applications rapidly

Working with AI/ML projects

Need extensive library ecosystem

Choose Java When:

Building large-scale applications

Need high performance and scalability

Developing Android mobile apps

Working in enterprise environments

 Require strong type safety

Building distributed systems

Need long-term maintainability

Best Practices for Learning Both

1. Start with Fundamentals:

Master basic concepts in one language first

Focus on problem-solving logic over syntax

Practice algorithm implementation in both

2. Compare and Contrast:

Write the same program in both languages

Understand design philosophy differences
Learn when each approach is better

3. Practice Projects:

Build a calculator in both languages

Create a student management system

Implement data structures (lists, stacks, queues)
Write file processing utilities
4. Common Mistakes to Avoid:

Don't mix syntax between languages

Understand variable scope differences

Remember Java's explicit typing requirements

Be careful with Python's indentation sensitivity

Programming Principles (Universal)

1. Write Clean Code:

Use meaningful variable and function names

Add comments to explain complex logic

Keep functions small and focused

Follow consistent formatting

2. Handle Errors Gracefully:

Always validate user input

Use proper exception handling

Provide meaningful error messages

 Test edge cases

3. Design for Reusability:

Break code into modular functions

Avoid code duplication

Use appropriate data structures

Plan before coding

Next Steps in Your Learning Journey

Immediate Next Steps:

1. Practice exercises in both languages daily

2. Build small projects to reinforce concepts

3. Join programming communities and forums
4. Read other developers' code

Advanced Topics to Explore:

Object-oriented design patterns

Database connectivity and SQL

Web frameworks (Flask/Django for Python, Spring for Java)
Version control with Git
Software testing methodologies

API development and consumption

Career Preparation:

Build a portfolio of projects in both languages

Contribute to open-source projects

Practice coding interview problems

Learn development tools and IDEs

Understand software development lifecycle

Final Recommendations
For Students:

Don't try to memorize syntax - focus on understanding concepts

Practice regularly with hands-on coding

Work on real projects that interest you

Don't be afraid to make mistakes - they're part of learning

Collaborate with other students and programmers

For Continued Learning:

Follow official language documentation

Take online courses and tutorials
Join coding bootcamps or computer science programs

Attend programming meetups and conferences

Stay updated with language updates and new features

Remember: The goal is not just to learn syntax, but to think like a programmer and solve problems
efficiently. Both Python and Java are powerful tools - the key is knowing when and how to use each
effectively.

Slide 14: Resources and References

Official Documentation
Python: [Link]/doc/ - Official Python documentation
Java: [Link]/javase/ - Oracle Java documentation

Online Learning Platforms

Codecademy, Coursera, edX, Khan Academy

LeetCode, HackerRank for practice problems
GitHub for code examples and projects

Recommended Books

"Python Crash Course" by Eric Matthes

"Effective Java" by Joshua Bloch
"Clean Code" by Robert Martin

Development Tools
IDEs: PyCharm, IntelliJ IDEA, Visual Studio Code

Online Editors: [Link], CodePen, Jupyter Notebooks

Thank you for learning Python and Java with us!

Happy coding! 🚀