snake case folder name

Author: NitkarshChourasia

file_handle/File handle binary/.env

@@ -0,0 +1 @@
+STUDENTS_RECORD_FILE= "student_records.pkl"

file_handle/File handle binary/Update a binary file2.py

@@ -0,0 +1,40 @@
+# updating records in a binary file
+
+import pickle
+import os
+
+base = os.path.dirname(__file__)
+from dotenv import load_dotenv
+
+load_dotenv(os.path.join(base, ".env"))
+student_record = os.getenv("STUDENTS_RECORD_FILE")
+
+## ! Understand how pandas works internally
+
+
+def update():
+    with open(student_record, "rb") as File:
+        value = pickle.load(File)
+        found = False
+        roll = int(input("Enter the roll number of the record"))
+
+        for i in value:
+            if roll == i[0]:
+                print(f"current name {i[1]}")
+                print(f"current marks {i[2]}")
+                i[1] = input("Enter the new name")
+                i[2] = int(input("Enter the new marks"))
+                found = True
+
+        if not found:
+            print("Record not found")
+
+    with open(student_record, "wb") as File:
+        pickle.dump(value, File)
+
+
+update()
+
+# ! Instead of AB use WB?
+# ! It may have memory limits while updating large files but it would be good
+# ! Few lakhs records would be fine and wouldn't create any much of a significant issues

file_handle/File handle binary/delete.py

@@ -0,0 +1,44 @@
+import logging
+import os
+import pickle
+
+from dotenv import load_dotenv
+
+base = os.path.dirname(__file__)
+load_dotenv(os.path.join(base, ".env"))
+
+logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
+student_record = os.getenv("STUDENTS_RECORD_FILE")
+
+
+def b_read():
+    # Opening a file & loading it
+    if not os.path.exists(student_record):
+        logging.warning("File not found")
+        return
+
+    with open(student_record, "rb") as F:
+        student = pickle.load(F)
+        logging.info("File opened successfully")
+        logging.info("Records in the file are:")
+        for i in student:
+            logging.info(i)
+
+
+def b_modify():
+    # Deleting the Roll no. entered by user
+    if not os.path.exists(student_record):
+        logging.warning("File not found")
+        return
+    roll_no = int(input("Enter the Roll No. to be deleted: "))
+    student = 0
+    with open(student_record, "rb") as F:
+        student = pickle.load(F)
+
+    with open(student_record, "wb") as F:
+        rec = [i for i in student if i[0] != roll_no]
+        pickle.dump(rec, F)
+
+
+b_read()
+b_modify()

file_handle/File handle binary/question 1 (elegible for remedial, top marks).py

@@ -0,0 +1,66 @@
+"""Amit is a monitor of class XII-A and he stored the record of all
+the students of his class in a file named “student_records.pkl”.
+Structure of record is [roll number, name, percentage]. His computer
+teacher has assigned the following duty to Amit
+
+Write a function remcount( ) to count the number of students who need
+ remedial class (student who scored less than 40 percent)
+and find the top students of the class.
+
+We have to find weak students and bright students.
+"""
+
+## Find bright students and weak students
+
+from dotenv import load_dotenv
+import os
+
+base = os.path.dirname(__file__)
+load_dotenv(os.path.join(base, ".env"))
+student_record = os.getenv("STUDENTS_RECORD_FILE")
+
+import pickle
+import logging
+
+# Define logger with info
+# import polar
+
+
+## ! Unoptimised rehne de abhi ke liye
+
+
+def remcount():
+    with open(student_record, "rb") as F:
+        val = pickle.load(F)
+        count = 0
+        weak_students = []
+
+        for student in val:
+            if student[2] <= 40:
+                print(f"{student} eligible for remedial")
+                weak_students.append(student)
+                count += 1
+        print(f"the total number of weak students are {count}")
+        print(f"The weak students are {weak_students}")
+
+        # ! highest marks is the key here first marks
+
+
+def firstmark():
+    with open(student_record, "rb") as F:
+        val = pickle.load(F)
+        count = 0
+        main = [i[2] for i in val]
+
+        top = max(main)
+        print(top, "is the first mark")
+
+        for i in val:
+            if top == i[2]:
+                print(f"{i}\ncongrats")
+                count += 1
+        print("The total number of students who secured top marks are", count)
+
+
+remcount()
+firstmark()

file_handle/File handle binary/read.py

@@ -0,0 +1,22 @@
+import pickle
+
+
+def binary_read():
+    with open("studrec.dat", "rb") as b:
+        stud = pickle.load(b)
+        print(stud)
+
+        # prints the whole record in nested list format
+        print("contents of binary file")
+
+        for ch in stud:
+            print(ch)  # prints one of the chosen rec in list
+
+            rno = ch[0]
+            rname = ch[1]  # due to unpacking the val not printed in list format
+            rmark = ch[2]
+
+            print(rno, rname, rmark, end="\t")
+
+
+binary_read()

file_handle/File handle binary/search record in binary file.py

@@ -0,0 +1,22 @@
+# binary file to search a given record
+
+import pickle
+from dotenv import load_dotenv
+
+
+def search():
+    with open("student_records.pkl", "rb") as F:
+        # your file path will be different
+        search = True
+        rno = int(input("Enter the roll number of the student"))
+
+        for i in pickle.load(F):
+            if i[0] == rno:
+                print(f"Record found successfully\n{i}")
+                search = False
+
+        if search:
+            print("Sorry! record not found")
+
+
+search()

file_handle/File handle binary/update2.py

@@ -0,0 +1,30 @@
+import pickle
+import os
+from dotenv import load_dotenv
+
+base = os.path.dirname(__file__)
+load_dotenv(os.path.join(base, ".env"))
+student_record = os.getenv("STUDENTS_RECORD_FILE")
+
+
+def update():
+    with open(student_record, "rb") as F:
+        S = pickle.load(F)
+        found = False
+        rno = int(input("enter the roll number you want to update"))
+
+        for i in S:
+            if rno == i[0]:
+                print(f"the currrent name is {i[1]}")
+                i[1] = input("enter the new name")
+                found = True
+                break
+
+        if found:
+            print("Record not found")
+
+        with open(student_record, "wb") as F:
+            pickle.dump(S, F)
+
+
+update()

file_handle/File handle text/counter.py

@@ -0,0 +1,34 @@
+"""
+Class resposible for counting words for different files:
+- Reduce redundant code
+- Easier code management/debugging
+- Code readability
+"""
+
+
+class Counter:
+    def __init__(self, text: str) -> None:
+        self.text = text
+
+        # Define the initial count of the lower and upper case.
+        self.count_lower = 0
+        self.count_upper = 0
+        self.count()
+
+    def count(self) -> None:
+        for char in self.text:
+            if char.lower():
+                self.count_lower += 1
+            elif char.upper():
+                self.count_upper += 1
+
+        return (self.count_lower, self.count_upper)
+
+    def get_total_lower(self) -> int:
+        return self.count_lower
+
+    def get_total_upper(self) -> int:
+        return self.count_upper
+
+    def get_total(self) -> int:
+        return self.count_lower + self.count_upper

file_handle/File handle text/file handle 12 length of line in text file.py

@@ -0,0 +1,38 @@
+import os
+import time
+
+file_name = input("Enter the file name to create:- ")
+
+print(file_name)
+
+
+def write_to_file(file_name):
+    if os.path.exists(file_name):
+        print(f"Error: {file_name} already exists.")
+        return
+
+    with open(file_name, "a") as F:
+        while True:
+            text = input("enter any text to add in the file:- ")
+            F.write(f"{text}\n")
+            choice = input("Do you want to enter more, y/n").lower()
+            if choice == "n":
+                break
+
+
+def longlines():
+    with open(file_name, encoding="utf-8") as F:
+        lines = F.readlines()
+        lines_less_than_50 = list(filter(lambda line: len(line) < 50, lines))
+
+        if not lines_less_than_50:
+            print("There is no line which is less than 50")
+        else:
+            for i in lines_less_than_50:
+                print(i, end="\t")
+
+
+if __name__ == "__main__":
+    write_to_file(file_name)
+    time.sleep(1)
+    longlines()

file_handle/File handle text/happy.txt

@@ -0,0 +1,11 @@
+hello how are you
+what is your name
+do not worry everything is alright
+everything will be alright
+please don't lose hope
+Wonders are on the way
+Take a walk in the park
+At the end of the day you are more important than anything else.
+Many moments of happiness are waiting
+You are amazing!
+If you truly believe.