updates on dynamic array subsection

Author: Blooverh

PythonDataStructsAndAlgo/Array_Based_Seqs/DynamicArrayImplementation.py

@@ -0,0 +1,51 @@
+"""The key is to provide means to grow the Array A that stores all the elements of a list.
+When an array is full and we append an element to the list we have to create a new array and copy 
+the elements of previous array to the new array """
+
+import ctypes # provides low-level arrays 
+
+class DynamicArray:
+    """A dynamic array class akin to a simplified Python list"""
+
+    def __init__(self):
+        """Create an empty array"""
+        self._n=0 #count actual elements
+        self._capacity=1 #default array capacity 
+        self._A= self._make_array(self.capacity) #low level array creation with capaity one containing nothing.
+
+    def __len__(self):
+        """Return the number of elements stored in the array"""
+        return self._n
+    
+    def __getitem__(self, k): # k is the position in the array where we will get the elements that is in that storage position (k).
+        if not 0<=k <self._n:
+            raise IndexError('Invalid Index')
+        return self._A[k] #retrieve from array
+    
+    def append(self, obj):
+        """Add object to the end of the array"""
+        if self._n == self._capacity: # if not enough room
+            self._resize(2*self._capacity) #double the capacity of the array
+        self._A[self._n]= obj
+        self._n +=1
+
+    def _resize(self, c): #nonpublic utity
+        """Resize the internal capacity of the array to c"""
+        B= self._make_array(c) # creation of new bigger array
+
+        for k in range(self._n): #for each existing value 
+            B[k]=self._A[k] 
+            
+        self._A=B #use the bigger Array as the new reference 
+        self._capacity=c
+
+    def _make_array(self, c):
+        """Retrun new array with capacity c"""
+        """ctypes.py_object is a data type in the library that represents a generic python object as a C language object """
+        return (c* ctypes.py_object) () #Check ctypes documentation. function with no arguments is returned.
+
+list=DynamicArray._make_array(list , 3)
+
+print(list.__len__())
+print(list.append(10))
+print(list.__getitem__(2))

PythonDataStructsAndAlgo/Array_Based_Seqs/example_5_1.py

@@ -0,0 +1,16 @@
+import sys 
+
+data=[]
+n=10
+for k in range(n):
+    a= len(data) # number of elements
+    b= sys.getsizeof(data) # actual size in bytes 
+    print('Length:{0:3d}; Size in bytes:{1:4d}'.format(a,b))
+    data.append(None) # increase length by one by appending None (Null) on every kth position of the list data
+
+"""In the array, we can reference the same object 4 times in memory allocations, thus the increase of 32 bytes every 4th element
+in the array"""
+"""Because a list is a referential structure, the result of getsizeof function for a list instance only includes 
+the size for representing its primary structure; does not account for memory used by the object itself that are elements of the list.
+Meaning each object at ith position in the array has its own memory size along with the memory size of its reference in the array."""
+print(data)

PythonDataStructsAndAlgo/Notes.md

@@ -73,3 +73,13 @@
 
 ### Dynamic Arrays and Amortization 
 >  When creating a low-level array in a computer system, the precise size of that array must be explicitly declared in order for the System to properly allocate a consecutive piece of memory for its storage.
+
+> Because the system might dedicate neighboring memory locations to store other data, the capacity of an array cannot trivially be increased by expanding into subsequent cells. In Python tuple and str instances, this constraint is not a problem. The instances of these classes (tuple and str) are immutable (not possible to modify), so the correct size for an underlying array can be fixed when the object is instantiated.
+
+> *Python's list class* presents a more insteresting abstractions. Although a list has a particular length when constructed, the class allows us to add elements to the list, with no apparent limit on the overall capacity of the list. To provide this abstraction, Python relies on *dynamic array* algorithm. 
+
+> Because a list is a referential structure, the result of getsizeof function for a list instance only includes the size for representing its primary structure; does not account for memory used by the objects that are elements of the list. Meaning each object at ith position in the array has its own memory size along with the memory size of its reference in the array.
+
+#### Implementing a dynamic array
+>  The key is to provide means to grow the Array A that stores all the elements of a list. When an array is full and we append an element to the list we have to create a new array and copy the elements of previous array to the new array
+>> A common used rule is for the new array to have twice the capacity of the existing array.