Python File Handling Basics for Beginners

• Day 30/30 Today I learned about Python File Handling Methods, which are used to work with files such as reading, writing, updating, and managing file content. File handling is very important because it allows us to store data permanently instead of keeping it only in memory while the program runs. 🔸 Common Python File Methods • open(): The close() method is used to close a file after use. It is important because it ensures that resources are released properly. file = open("sample.txt", "r") print(file) file.close() • read(): The read() method is used to read the entire content of a file at once. It is useful when we want to access all the text stored inside a file. with open("sample.txt", "r") as file: print(file.read()) • readline(): The readline() method reads one line at a time from the file. It is useful when working with large files. with open("sample.txt", "r") as file: print(file.readline()) • readlines(): The readlines() method reads all lines of a file and stores them in a list. Each line becomes a separate list element. This is helpful when we want to process file data line by line using loops. with open("sample.txt", "r") as file: print(file.readlines()) • write(): The write() method is used to write data into a file. If the file is opened in write mode, it will overwrite the existing content. This method is useful for saving text or program output into a file. with open("sample.txt", "w") as file: file.write("Hello Python") • writelines(): The writelines() method is used to write multiple lines into a file at once. It takes a list of strings and writes them to the file. This is useful when saving structured text data. lines = ["Python\n", "File Handling\n", "Methods\n"] with open("sample.txt", "w") as file: file.writelines(lines) • close(): The close() method is used to close a file after use. It is important because it ensures that resources are released properly. file = open("sample.txt", "r") file.close() print("File closed") • flush(): The readline() method reads one line at a time from the file. It is useful when working with large files. file = open("sample.txt", "w") file.write("Data saved") file.flush() file.close() • seek(): The flush() method forces the file buffer to write data immediately into the file without closing it. This is useful when we want to ensure that the data is saved instantly. with open("sample.txt", "r") as file: file.seek(0) print(file.read()) • tell(): The seek() method is used to move the file pointer to a specific position. This allows us to read or write from a particular point in the file. It is useful for random file access. print(file.tell()) When opening a file, Python uses different modes depending on the operation: "r" → Read mode "w" → Write mode "a" → Append mode "x" → Create mode "b" → Binary mode "t" → Text mode (default) #Python #File_Handling #BengaluruStudents #BangaloreIT #BTMLayout #fortunecloud Fortune Cloud Technologies Private Limited

*Python Data Structures interview questions with answers:* 📍 *1. What are the main built-in data structures in Python* *Answer:* Python provides four primary built-in data structures: – *List*: Ordered, mutable, allows duplicates – *Tuple*: Ordered, immutable, allows duplicates – *Set*: Unordered, mutable, no duplicates – *Dictionary*: Key-value pairs, unordered (ordered from Python 3.7+), mutable Each structure serves different use cases based on performance, mutability, and uniqueness. 📍 *2. What is the difference between a list and a tuple in Python* *Answer:* – *List*: Mutable, can be modified after creation – *Tuple*: Immutable, cannot be changed once defined Lists are used when data may change; tuples are preferred for fixed collections or as dictionary keys. ```python my_list = [1, 2, 3] my_tuple = (1, 2, 3) ``` 📍 *3. What is the difference between a set and a frozenset* *Answer:* – *Set*: Mutable, supports add/remove operations – *Frozenset*: Immutable, hashable, can be used as dictionary keys or set elements Use frozensets when you need a fixed, unique collection that won’t change. ```python my_set = {1, 2, 3} my_frozenset = frozenset([1, 2, 3]) ``` 📍 *4. What are common dictionary methods in Python* *Answer:* – `get(key)`: Returns value or default – `keys()`, `values()`, `items()`: Access dictionary contents – `update()`: Merges another dictionary – `pop(key)`: Removes key and returns value – `clear()`: Empties the dictionary ```python person = {"name": "Alice", "age": 30} print(person.get("name")) print(person.items()) ``` 📍 *5. How do you iterate over different data structures in Python* *Answer:* – *List/Tuple*: Use `for item in sequence` – *Set*: Same as list, but unordered – *Dictionary*: Use `for key, value in dict.items()` You can also use `enumerate()` for index-value pairs and `zip()` to iterate over multiple sequences. ```python for key, value in person.items(): print(key, value) ``` *Double Tap ❤️ For More*

Day 9 of my Python journey — for loops. If while loops are about "keep going until done," for loops are about "do this for every item." This distinction matters because most real programming is about processing collections — lists of users, rows of data, records from a database, items in a cart. Today I focused not just on how for loops work, but on the patterns that make them professional. enumerate() — stop tracking indexes manually # Beginner approach — works but is not Pythonic for i in range(len(students)):   print(f"{i+1}. {students[i]['name']}") # Professional approach for rank, student in enumerate(students, start=1):   print(f"{rank}. {student['name']}") enumerate() gives you both the index and the value on every iteration. Using it instead of manual index tracking is one of the most visible signs of Python experience. Every code review at a professional company will flag the first approach as beginner code. zip() — iterate two related collections simultaneously names = ["Rahul", "Priya", "Arjun", "Neha"] scores = [87, 94, 72, 88] for name, score in zip(names, scores):   status = "Pass" if score >= 40 else "Fail"   print(f"{name:<10} | {score:>3} | {status}") zip() pairs corresponding elements from two lists and iterates them together. This pattern is used daily in data engineering: matching timestamps with values, pairing users with permissions, correlating products with prices. The three patterns that solve 80% of loop problems Accumulator: total = 0; for x in data: total += x Counter: count = 0; for x in data: if condition: count += 1 Collector: result = []; for x in data: if condition: result.append(x) Recognise the pattern first, then write the loop. This is what separates fast problem-solving from slow trial-and-error. Nested loops and cost awareness A loop inside a loop is O(n²). For 100 items that is 10,000 operations. For 1,000 items that is 1,000,000. I learned today to consciously choose when nesting is justified and when a different approach is needed. This thinking starts in Week 2, not Week 20. Every data processing job in Python depends on this. #Python#Day9#ConditionalLogic#SelfLearning#CodewithHarry#PythonBasics#w3schools.com#W3Schools

1 Billion Row Challenge in Python — Comparing Different Processing Approaches. Processing 1 billion rows sounds like a distributed systems problem. Sometimes it isn’t. Recently I implemented the 1 Billion Row (1BRC) in Python to explore how different data processing approaches behave when working with large datasets. The task itself is simple. Given a file containing temperature measurements from weather stations, compute the minimum, mean, and maximum temperature per station. The challenge comes from the data volume. A full dataset can reach 1 billion rows, roughly 13GB of data. Rather than focusing on a single solution, I wanted to compare different execution models available in the Python ecosystem. The project ended up with two main components. 1. Dataset generation An optimized generator using multiprocessing + NumPy to quickly create very large files. 2. Data processing Multiple implementations of the same computation using different engines. The approaches tested were: Polars — a high-performance DataFrame engine designed for parallel execution DuckDB — an embedded analytical database capable of querying files directly Numba — JIT compilation to accelerate Python loops PySpark — distributed processing using Apache Spark For the initial comparison I ran tests on 1 million rows, mainly to observe relative differences between the approaches. Implementation Approximate Time: Polars~0.02s DuckDB~0.04s Numba~0.15s PySpark~4.00s One result that stood out was DuckDB's performance. Initially I expected the Numba implementation to be the most competitive due to JIT compilation and low-level optimizations. While it performed well, it was still outpaced by higher-level engines. This highlights something that is often underestimated in data engineering: Performance is not only about local optimizations. It is about the execution engine. Tools like DuckDB and Polars benefit from years of work on: vectorized execution optimized parsers efficient memory management parallel query planning Another interesting case was PySpark. With smaller datasets, the initialization and orchestration overhead dominates execution time. This illustrates why distributed frameworks only become advantageous once the scale actually requires distribution. In the end, the experiment became less about finding “the best tool” and more about understanding where each approach fits. In real systems, the most efficient architecture often comes from combining multiple tools within the same pipeline. The full implementation is available here in 1 comment: If you’ve used DuckDB or Polars in production pipelines, I’d be interested to hear about your experience. #DataEngineering #Python #BigData #DataProcessing #DuckDB #Polars #PySpark #DataInfrastructure

Lists in Python A versatile data structure used to store multiple items in a single variable. 🎯 1. What is a List? Lists are ordered, mutable collections of items that allow duplicate elements. They are defined using square brackets []. 🎯 2. Creating a List A list by placing comma-separated values inside square brackets. python # Example my_list = [1, "Hello", 3.14, True] 🎯 3. Accessing List Elements & Indexing zero-based indexing to access elements. python # Example fruits = ["apple", "banana", "cherry"] print(fruits[0]) # First element print(fruits[-1]) # Last element 🎯 4. List Slicing Access a range of elements Syntax [start:stop:step]. python # Example numbers = [10, 20, 30, 40, 50, 60] print(numbers[1:4]) # From index 1 up to (but not including) 4 print(numbers[::-1]) # Reverse the list Output: [20, 30, 40] [60, 50, 40, 30, 20, 10] 🎯 5. Modifying Lists Lists are mutable, meaning you can change their items. python # Example fruits = ["apple", "banana", "cherry"] fruits[1] = "blueberry" # Change index 1 print(fruits) Output: [apple, blueberry, cherry] 🎯 6. List Methods append() : Adds an item to the end. python fruits.append("orange") insert() : Adds an item at a specific position. python fruits.insert(1, "mango") remove() : Removes the first occurrence of a specific value. python fruits.remove("banana") pop() : Removes and returns an item at a specific index (or the last item if no index is specified). python last_item = fruits.pop() sort() : Sorts the list in place. 🎯 List Comprehensions A list comprehension offers a concise way to create lists in Python based on existing lists or iterables. Basic Syntax: new_list = [expression for item in iterable if condition] 🎯 1. Creating a List of Squares Instead of using a for loop to append squares, you can do it in one line. python # Traditional loop squares = [] for x in range(1, 6): squares.append(x*2) 🎯 List comprehension squares = [x*2 for x in range(1, 6)] print(squares) Output: [1, 4, 9, 16, 25] 🎯 2. Filtering with if Condition You can add a condition to filter elements from the original list. python numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] # Get only even numbers evens = [x for x in numbers if x % 2 == 0] print(evens) Output: [2, 4, 6, 8, 10] 🎯 3. Transforming Strings You can apply string methods like .upper() during creation. python fruits = ["apple", "banana", "cherry"] # Convert all to uppercase upper_fruits = [fruit.upper() for fruit in fruits] print(upper_fruits) Output: ['APPLE', 'BANANA', 'CHERRY'] 🎯 4. Flattening a Nested List This is a highly efficient way to turn a list of lists into a single flat list. python nested_list = [[1, 2], [3, 4], [5, 6]] # Flatten the list flatlist = [item for sublist in nestedlist for item in sublist] print(flat_list) Output: [1, 2, 3, 4, 5, 6] #PythonProgramming #PythonList #DataScience #CodingTips #PythonTutorial #SoftwareDevelopment #Programming

Python Prototypes vs. Production Systems: Lessons in Logic Rigor 🛠️ This week, I stopped trying to write code that "just works" and started writing code that refuses to crash. As an aspiring Data Scientist, I’m learning that stakeholders don’t just care about the output—they care about uptime. If a single "typo" from a user kills your entire analytics pipeline, your system isn't ready for the real world. Here are the 4 "Industry Veteran" shifts I made to my latest Python project: 1. EAFP over LBYL (Stop "Looking Before You Leap") In Python, we often use if statements to check every possible error (Look Before You Leap). But a "Senior" approach often favors EAFP (Easier to Ask for Forgiveness than Permission) using try/except blocks. Why? if statements become "spaghetti" when checking for types, ranges, and existence all at once. Rigor: A try block handles the "ABC" input in a float field immediately, keeping the logic clean and the performance high. 2. The .get() Method: Killing the KeyError Directly indexing a dictionary with prices[item] is a ticking time bomb. If the key is missing, the program dies. The Fix: I’ve switched to .get(item, 0.0). This allows for a "Default Value" fallback in a single line, preventing "Dictionary Sparsity" from breaking my calculations. 3. Preventing the "System Crush" Stakeholders hate downtime. I implemented a while True loop combined with try/except for all user inputs. The Goal: The program should never end unless the user explicitly chooses to "Quit." Every "bad" input now triggers a helpful re-prompt instead of a system failure. 4. Precision in Data Type Conversion Logic errors often hide in the "Conversion Chain." I focused on the transition from String (from input()) to Int (for indexing). The Off-by-One Risk: Users think in "1-based" counting, but Python is "0-based." I’ve made it a rule to always subtract 1 from the integer input immediately to ensure the correct data point is retrieved every time. The Lesson: Coding is about the architecture of the "Why" just as much as the syntax of the "What." [https://lnkd.in/gvtiAKUb] #Python #DataScience #CodingJourney #CleanCode #BuildInPublic #SoftwareEngineering #SeniorDataScientist #TechMentor

Python Program : *🚀 Library Management System 📚* This project builds a simple application to manage library books, including adding, viewing, issuing, and returning books. *🧠 Basic Structure:* - List → store all books - Dictionary → each book (title + status) - Functions → handle operations - File Handling (JSON) → persist data *💻 Python Code:* ``` import json library = [] def add_book(): title = input("Enter book title: ") library.append({"title": title, "issued": False}) print("Book added") def show_books(): if not library: print("No books available") else: print("\nLibrary Books:") for i, book in enumerate(library): status = "Issued" if book["issued"] else "Available" print(f"{i+1}. {book['title']} - {status}") def issue_book(): show_books() try: index = int(input("Enter book number to issue: ")) - 1 if 0 <= index < len(library): if not library[index]["issued"]: library[index]["issued"] = True print("Book issued") else: print("Book already issued") else: print("Invalid choice") except: print("Enter valid number") def return_book(): show_books() try: index = int(input("Enter book number to return: ")) - 1 if 0 <= index < len(library): if library[index]["issued"]: library[index]["issued"] = False print("Book returned") else: print("Book was not issued") else: print("Invalid choice") except: print("Enter valid number") def save_data(): with open("library.json", "w") as file: json.dump(library, file) def load_data(): try: with open("library.json", "r") as file: data = json.load(file) library.extend(data) except: pass # Load existing data load_data() # Menu loop while True: print("\n1. Add Book") print("2. View Books") print("3. Issue Book") print("4. Return Book") print("5. Exit") choice = input("Enter choice: ") if choice == "1": add_book() elif choice == "2": show_books() elif choice == "3": issue_book() elif choice == "4": return_book() elif choice == "5": save_data() print("Data saved. Exiting...") break else: print("Invalid choice")``` *🧠 Explanation:* 1. Data Model: Each book is stored as a dictionary with title and issued status. 2. Core Features: Add, View, Issue, and Return books. 3. State Management: Boolean flag (issued) controls logic and prevents issuing already issued books. 4. File Persistence: Data saved in library.json and loaded on program start. *🚀 Outcome:* - Manage state using flags (True/False) - Build multi-action systems - Handle real-world logic (availability tracking) - Design structured applications

🚀 Mastering Python Loops for Data Analysis Loops are one of the most powerful concepts in Python programming because they enable developers and data analysts to automate repetitive tasks and process data efficiently. Understanding how loops work is essential when working with datasets, performing data cleaning, or building automated workflows in Python. 🔹 The Fundamentals of Loops Loops are blocks of code that execute repeatedly until a condition is met. They are widely used in programming to automate repetitive operations, especially when processing large datasets. Instead of writing the same instructions multiple times, loops allow a program to repeat tasks automatically. Python mainly uses two types of loops: for loops and while loops. Each serves a different purpose depending on the nature of the task. 🔹 The For Loop The for loop is commonly used when iterating through sequences such as lists, tuples, dictionaries, sets, or strings. It is particularly useful when the number of iterations is known in advance. For example, a for loop can iterate through a list of values or a sequence of numbers using the range() function. This function generates a sequence of numbers, making it easier to repeat tasks for a fixed number of iterations. This type of loop is widely used in data processing, list manipulation, and dataset iteration. 🔹 The While Loop The while loop works differently because it executes a block of code as long as a specific condition remains true. It is ideal when the number of iterations depends on a condition rather than a predefined count. 🔹 Loop Control and Efficiency Python provides control mechanisms that help manage loops more effectively. • Break allows the loop to terminate immediately when a condition is met. • Continue skips the current iteration and moves to the next cycle of the loop. 🔹 List Comprehensions Python also offers list comprehensions, which provide a concise and efficient way to create lists in a single line of code. Instead of writing multiple lines using traditional loops, list comprehensions simplify the process and improve readability. 🔹 Nested Loops and Multi-Dimensional Data Nested loops are commonly used when working with complex data structures such as matrices or lists within lists. These loops allow developers to iterate through rows and columns of multi-dimensional data structures. This technique is often applied in data analysis, machine learning, and algorithm development. 🔹 Application in Data Analysis Loops are essential in real-world data analysis workflows. For instance, when working with datasets using libraries such as pandas, developers often iterate through DataFrame rows to access and process data. A typical workflow may involve: Raw Data → Data Cleaning → Loop Processing → Final Interpretation and Insights #Python #DataAnalysis #Programming #PythonProgramming #Coding #DataScience #Automation #LearnPython #TechSkills

*🚀Problem Solving with DSA - Day 47: Under the Hood | Internal Working of Python Dictionaries 🛠️🐍* ->Welcome to Day 47 of my 60-Day DSA Challenge! Today, we are cracking open the Python Dictionary to see how it achieves that lightning-fast O(1) speed. 🏗️ The Architecture: Buckets & Key-Value Pairs ->In Python, a dictionary is essentially a Hash Table. When you do my_dict["name"] = "Sriman", here is what happens: ->Hashing: Python calls the hash() function on your key ("name"). This generates a large integer. ->Indexing: It takes that integer and performs a modulo operation with the current size of the hash table: index = hash("name") % array_size. ->Storage: It stores the key, the hash value, and the actual value in a "Bucket" at that index. ⚔️ Collision Handling in Python: Open Addressing ->Unlike Java (which uses Chaining/Linked Lists), Python uses Open Addressing with a special probing technique. ->If a collision occurs (two keys map to the same index), Python doesn't create a list. ->Instead, it looks for another empty slot using a Pseudo-random Probing sequence. This keeps the data "flat" and cache-friendly. 📈 Dynamic Resizing: The Load Factor ->A HashMap works best when it's not too full. ->Load Factor: It’s the ratio of (number of items) / (table size). ->Resizing: When the dictionary gets about 2/3rd full, Python automatically creates a larger table (usually 2x or 4x the size) and re-hashes all existing keys into the new table. This ensures operations stay O(1). 💻 Python Code: Simulating the Logic # How Python sees your data key = "Day47" value = "HashMap Internal" # 1. Get Hash h = hash(key) # 2. Map to Index (Simplified) capacity = 8 index = h & (capacity - 1) # Efficient bitwise way to do modulo print(f"Key: {key} hashes to index: {index}") 📊 Python Dict Optimization (Compact Dict): ->Since Python 3.6+, dictionaries are ordered by default. They use a split-table design (an indices array and an entries array) which saves a lot of memory. 🧠 Challenge of the Day: ->"If Python uses Open Addressing, what happens to the search time if we keep adding elements without ever resizing the table? Why is the 2/3rd threshold important?" 📈 Progress Tracking: Current Topic: Dictionary Internals Status: Day 47/60 ✅ (78% Complete!) Next Up: Handling Collisions Understanding the 'Internal Magic' makes you a better developer, not just a coder mama! Ready to apply this speed to some real interview problems tomorrow? 👇 #60DaysOfCode #Python #HashMap #Hashing #SoftwareEngineering #InternalWorking #BigO #DataStructures #Algorithms #PlacementPrep #TechEducation

🚀 Python for Data Analyst- Advanced Set Concepts in Python (Part 3)-(Post 9) These are small concepts individually, but together they make sets very powerful in real-world Python work. 1️⃣ issubset() Checks whether all elements of one set are present in another. s1 = {1, 2, 3, 4, 5} s2 = {4, 5} print(s2.issubset(s1)) Output: True More examples: A = {1, 2, 3} B = {1, 2, 3, 4, 5} C = {1, 2, 4, 5} print(A.issubset(B)) # True print(B.issubset(A)) # False print(A.issubset(C)) # False print(C.issubset(B)) # True 2️⃣ issuperset() Checks whether one set contains all elements of another. A = {4, 1, 3, 5} B = {6, 0, 4, 1, 5, 3} print(A.issuperset(B)) print(B.issuperset(A)) Output: False True 3️⃣ isdisjoint() Checks whether two sets have no common elements. s1 = {1, 2, 3} s2 = {4, 5, 6} print(s1.isdisjoint(s2)) Output: True If there is at least one common value: set1 = {2, 4, 5, 6} set3 = {1, 2} print(set1.isdisjoint(set3)) Output: False It also works with: list tuple dictionary string Important: For dictionaries, only keys are checked. 4️⃣ copy() Creates a shallow copy of a set. set1 = {1, 2, 3, 4} set2 = set1.copy() print(set2) Using copy() is useful because direct assignment: set2 = set1 makes both variables point to the same set. With copy(), modifications in the copied set do not affect the original: first = {'g', 'e', 'k', 's'} second = first.copy() second.add('f') print(first) print(second) 5️⃣ frozenset A frozenset is like a set, but immutable. Once created: cannot add cannot remove cannot update Example: fs = frozenset([1, 2, 3, 4, 5]) print(fs) Output: frozenset({1, 2, 3, 4, 5}) Useful when you need a set-like structure that should not change. 6️⃣ Typecasting into Sets The set() constructor can convert: list tuple string range dictionary Examples: print(set([1, 2, 2, 3])) print(set((1, 1, 2, 3))) print(set("GeeksforGeeks")) print(set(range(3, 8))) print(set({'x': 1, 'y': 2})) Important: When converting a dictionary to a set, only keys are included. 7️⃣ set() Function Summary Syntax: set(iterable) removes duplicates automatically creates empty set if no argument is passed accepts only iterables Examples: set() set([4, 5, 5, 6]) set((1, 1, 2, 3)) set("hello") 8️⃣ min() and max() with Sets You can find minimum and maximum values in a set. s1 = {4, 12, 10, 9, 13} print(min(s1)) print(max(s1)) Output: 4 13 ⚠️ For heterogeneous sets like {"Geeks", 11}, min() and max() raise TypeError because Python cannot compare different types. 9️⃣ Using sorted() with Sets sorted() works on any iterable, including sets. It returns a new sorted list and does not modify the original set. s = {5, 3, 9, 1, 7} sorted_s = sorted(s) print(sorted_s) Output: [1, 3, 5, 7, 9] Descending order print(sorted(s, reverse=True)) Sorting strings in a set A = {'ab', 'ba', 'cd', 'dz'} print(sorted(A)) #Python #PythonLearning #DataAnalytics #Sets #LearningInPublic