1. DSA

2. Sorting 3. Searching 4. Stack 5. Linked List

Author: majid shahbaz

README.md

@@ -210,6 +210,7 @@
   4.5.7.2. Intersection Operator (&)
   4.5.7.3. Difference Operator (-)
   4.5.7.4. Symmetric Difference Operator (^)
+
 #### [4.6. Conditional Statements](https://github.com/Majid460/python_practice_part1/blob/main/src/basic/conditional)
  4.6.1. Python Logical Conditions
   4.6.1.1. Comparison Operators (==, !=, <, <=, >, >=)

src/basic/filehandling/filehandling.py

@@ -0,0 +1,162 @@
+"""
+File handling is an important part of any web application.
+
+Python has several functions for creating, reading, updating, and deleting files.
+
+File Handling
+The key function for working with files in Python is the open() function.
+The open() function takes two parameters; filename, and mode.
+There are four different methods (modes) for opening a file:
+
+"r" - Read - Default value. Opens a file for reading, error if the file does not exist
+"a" - Append - Opens a file for appending, creates the file if it does not exist
+"w" - Write - Opens a file for writing, creates the file if it does not exist
+"x" - Create - Creates the specified file, returns an error if the file exists
+
+In addition you can specify if the file should be handled as binary or text mode
+"t" - Text - Default value. Text mode
+"b" - Binary - Binary mode (e.g. images)
+
+
+"""
+# 1. To open a file use open()
+file = open("test.txt","rt") # Because "r" for read, and "t" for text are the default values, you do not need to specify them.
+print(file.read())
+file.close()
+"""
+Q. What is life?
+A. Life is temporary environment to execute certain tasks.
+"""
+# 2. Open with "with"
+"""
+Then you do not have to worry about closing your files, the with statement takes care of that.
+"""
+with open("test.txt","rt") as f:
+ print(f.read())
+
+"""
+Q. What is life?
+A. Life is temporary environment to execute certain tasks.
+"""
+"""
+Note: You should always close your files. In some cases, due to buffering, changes made to a file may not show until you close the file.
+"""
+
+# 3. Read Only Parts of the File
+"""
+
+By default the read() method returns the whole text, but you can also specify how many characters you want to return:
+"""
+with open("test.txt","rt") as f:
+ print(f.read(5))
+ # Reads first 5 characters
+# Q. Wh
+
+# 4. Read lines
+with open("test.txt","rt") as f:
+ print(f.readline()) # Reads first line
+
+#By calling readline() two times, you can read the two first lines:
+
+"""Example
+Read two lines of the file:
+"""
+
+with open("test.txt") as f:
+ print(f.readline())
+ print(f.readline())
+
+#By looping through the lines of the file, you can read the whole file, line by line:
+
+"""Example
+Loop through the file line by line:"""
+
+with open("test.txt") as f:
+ for x in f:
+ print(x)
+
+# Read second line
+with open("test.txt") as f:
+ lines = f.readlines()
+ if len(lines)>=2:
+ print(f"second line:: {lines[1]}")
+# second line:: A. Life is temporary environment to execute certain tasks.
+
+# Read last line
+with open("test.txt") as f:
+ lines = f.readlines()
+ print(f"last line:: {lines[len(lines)-1]}")
+# second line:: Q. How?
+
+### Write to file
+print("-------------------Write in file------------------")
+"""
+Write to an Existing File
+To write to an existing file, you must add a parameter to the open() function:
+
+"a" - Append - will append to the end of the file
+
+"w" - Write - will overwrite any existing content
+"""
+# with open("test.txt","w") as f:
+# f.write("Because life is harsh")
+# #open and read the file after the appending:
+# with open("test.txt") as f:
+# print(f.read())
+
+# with open("test.txt","a") as f:
+# f.write("A. Because life is harsh.\n")
+# #open and read the file after the appending:
+# with open("test.txt") as f:
+# print(f.read())
+
+
+print("-------------------Create a new file------------------")
+
+# with open("newfile.txt","x") as f:
+# f.write("Hey new file is created \n")
+
+# Remove a file
+import os
+# os.remove("newfile.txt")
+
+# if os.path.exists("newfile.txt"):
+# os.remove("newfile.txt")
+# else:
+# print("The file does not exist")
+
+print("------------------- Json Handling ------------------")
+"""
+JSON (JavaScript Object Notation)
+
+- A standard data interchange format supported in Python via the json module.
+- Serialization = converting Python objects → JSON string.
+- Deserialization = converting JSON string → Python object.
+- JSON is widely used for data exchange and is interoperable across languages.
+"""
+
+import json
+
+# To convert a dict to json use dumps
+
+x = {
+ "name":"Test",
+ "age":20
+}
+"""The json.dumps() method has parameters to order the keys in the result:
+
+Example
+Use the sort_keys parameter to specify if the result should be sorted or not:"""
+
+y = json.dumps(x, indent=4, sort_keys=True)
+print(y)
+"""
+{
+ "age": 20,
+ "name": "Test"
+}
+"""
+
+# Convert json to dict
+js = json.loads(y)
+print(js)

src/basic/filehandling/newfile.txt

@@ -0,0 +1 @@
+Hey new file is created 

src/basic/filehandling/test.txt

@@ -0,0 +1,6 @@
+Q. What is life?
+A. Life is temporary environment to execute certain tasks.
+Q. How?
+A. Because life is harsh.
+A. Because life is harsh.
+A. Because life is harsh.

src/basic/functions/functions.py

@@ -129,19 +129,18 @@ def myfunction():
 def cal_area(length,width,/):
  return length*width
 
-#area = cal_area(lenght = 10,width = 20)
+#area = cal_area(length = 10,width = 20)
 #print(f"Area is :: {area}")
 
 # We will get error because we have to pass positional arguments just not any keyword argument
 """
-area = cal_area(lenght = 10,width = 20)
+area = cal_area(length = 10,width = 20)
 Error:
 Traceback (most recent call last):
  File "/Users/macbookpro/Documents/Python Practice/python_practice_part1/src/basic/functions/functions.py", line 132, in <module>
- area = cal_area(lenght = 10,width = 20)
+ area = cal_area(length = 10,width = 20)
  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 TypeError: cal_area() got some positional-only arguments passed as keyword arguments: 'width'
-
 """
 
 # To fix it we need to pass only positional because we have used forward slash (/) right after the end of arguments

src/basic/functions/lambda.py

@@ -0,0 +1,22 @@
+"""
+A lambda function is a small anonymous function.
+
+A lambda function can take any number of arguments, but can only have one expression.
+
+lambda arguments : expression
+"""
+# a represents the arguments
+
+x= lambda a:a+4
+print(x(2))
+
+# 6
+
+def add(a):
+ return lambda y:y+a
+
+lam = add(2) # It returns the inner lambda function
+
+print(lam(2))
+# 4
+

src/datastructures/linkedlist/Linkedlist.py

@@ -0,0 +1,137 @@
+"""
+A Linked List is, as the word implies, a list where the nodes are linked together. Each node contains data and a pointer.
+The way they are linked together is that each node points to where in the memory the next node is placed.
+
+
+Linked Lists
+A linked list consists of nodes with some sort of data, and a pointer, or link, to the next node.
+
+[data|next] -> [data|next] -> [data|next] -> [data|next] -> null
+
+A singly linked list.
+A big benefit with using linked lists is that nodes are stored wherever there is free space in memory, the nodes do not have to be stored contiguously right after each other like elements are stored in arrays. Another nice thing with linked lists is that when adding or removing nodes, the rest of the nodes in the list do not have to be shifted.
+"""
+from src.basic.datatypes.casting.casting import height
+
+
+# Singly linklist
+class Node:
+ def __init__(self, data):
+ self.data = data
+ self.next = None
+ self.prev = None # Only for doubly
+
+
+class LinkList:
+ def __init__(self):
+ self.head = None
+
+ def add_node(self, data):
+ new_node = Node(data)
+
+ if self.head is None:
+ self.head = new_node
+ return
+ current_node = self.head
+ while current_node.next is not None:
+ current_node = current_node.next
+ current_node.next = new_node
+
+ def display(self):
+ current_node = self.head
+ while current_node is not None:
+ print(current_node.data, end=" -> ")
+ current_node = current_node.next
+ print("null")
+
+
+# Doubly linklist
+class DoublyLinkList:
+
+ def __init__(self):
+ self.head = None
+ self.tail = None
+
+ def add_node(self, data):
+ new_node = Node(data)
+
+ if self.head is None:
+ self.head = self.tail = new_node
+ return
+ self.tail.next = new_node
+ new_node.prev = self.tail
+ self.tail = new_node
+
+ def print_forward(self):
+ current = self.head
+ while current:
+ print(current.data, end=" -> ")
+ current = current.next
+ print("None")
+
+ def print_backward(self):
+ current = self.tail
+ while current:
+ print(current.data, end=" -> ")
+ current = current.prev
+ print("None")
+
+
+# Circular Single linklist
+class CircularLinkList:
+ def __init__(self):
+ self.head = None
+
+ def add_node(self, data):
+ new_node = Node(data)
+
+ if self.head is None:
+ self.head = new_node
+ new_node.next = self.head
+ return
+ current = self.head
+ while current.next is not self.head:
+ current = current.next
+ current.next = new_node
+ new_node.next = self.head
+
+ def display(self, count):
+ if not self.head:
+ print("List is empty")
+ return
+ current = self.head
+ i = 0
+ lowest = current.data
+ while i < count:
+ if current.data < lowest:
+ lowest = current.data
+ print(current.data, end=" -> ")
+ current = current.next
+ i += 1
+ print("None", end=" \n")
+ print(f"Lowest value is: {lowest}", end="\n")
+
+
+if __name__ == '__main__':
+ # Singly
+ print("---------------------- Singly ------------------------", end="\n")
+ linkList = LinkList()
+ linkList.add_node(1)
+ linkList.add_node(2)
+ linkList.add_node(3)
+ linkList.display()
+ # Doubly
+ print("---------------------- Doubly ------------------------", end="\n")
+ doubly = DoublyLinkList()
+ doubly.add_node(11)
+ doubly.add_node(12)
+ doubly.add_node(13)
+ doubly.print_forward()
+ doubly.print_backward()
+ # Circular
+ print("---------------------- Circular ------------------------", end="\n")
+ circular = CircularLinkList()
+ circular.add_node(111)
+ circular.add_node(112)
+ circular.add_node(113)
+ circular.display(4)