DEV Community: ckorley4

Encapsulation in Python

ckorley4 — Fri, 29 Mar 2024 14:54:08 +0000

The process of wrapping up variables and methods into a single entity is known as Encapsulation. It is one of the underlying concepts in object-oriented programming (OOP). It acts as a protective shield that puts restrictions on accessing variables and methods directly, and can prevent accidental or unauthorized modification of data. Encapsulation also makes objects into more self-sufficient, independently functioning pieces.

Why do we need Encapsulation in Python?
The advantages of Encapsulation in Python can be summed up as follows –

Encapsulation provides well-defined, readable code
The primary advantage of using Encapsulation in Python is that as a user, we do not need to know the architecture of the methods and the data and can just focus on making use of these functional, encapsulated units for our applications. This results in a more organized and clean code. The user experience also improves greatly and makes it easier to understand applications as a whole.
Prevents Accidental Modification or Deletion
Another advantage of encapsulation is that it prevents the accidental modification of the data and methods. Let’s consider the example of NumPy again, if I had access to edit the library, then I might make a mistake in the implementation of the mean function and then because of that mistake, thousands of projects using NumPy would become inaccurate.
Encapsulation provides security
Encapsulation in Python is achieved through the access modifiers. These access modifiers ensure that access conditions are not breached and thus provide a great user experience in terms of security.
Encapsulation provides reusability
It is easier to reuse code when it is encapsulated. Creating objects that contain common functionality allows us to reuse them in many settings.

Access Modifiers in Python encapsulation
Sometimes there might be a need to restrict or limit access to certain variables or functions while programming. That is where access modifiers come into the picture.

Now when we are talking about access, 3 kinds of access specifiers can be used while performing Encapsulation in Python. They are as follows :

Public Members
Private Members
Protected Members

Lets take a look at this example



# Encapsulation in Python
# A simple example

class Original: 
    def __init__(self): 
        self._protected_variable= 10

# Creating a derived class 
class Derived(Original): 
    def __init__(self): 

        # Calling constructor of  Original Class
        Original.__init__(self) 
        print("Calling the member of the original class: ",  
              self._protected_variable) 

        # Modifying the protected variable: 
        self._protected_variable = 200
        return(f'Protected member outside class:{self._protected_variable}') 

object_one = Derived() 
object_two = Original() 

print("Protected member of Derived: ", object_one._protected_variable) 

print("Protected member of Original: ", object_two._protected_variable)

Conclusion
Encapsulation in Python refers to the practice of hiding the implementation details of an object or class, and only exposing a public interface for interacting with it.

Encapsulation is achieved through the use of access modifiers such as 'public', 'private', and 'protected'.

Variables and methods declared with the 'private' or 'protected' access modifiers are not accessible from outside the class, while those declared as 'public' are.

Encapsulation helps to promote code reusability, maintainability, and security by preventing external code from accessing or modifying the internal state of an object or class.

The '' or '_' prefix can be used to indicate a variable or method as private, however, it is not enforced by the interpreter and can still be accessed.

In Python, encapsulation is not as strict as in other languages such as Java, as it does not have the concept of protected variables and methods.

https://www.educative.io/answers/what-is-encapsulation-in-python
https://www.scaler.com/topics/python/encapsulation-in-python/

Memoization in Python; an alternative to Recursion

ckorley4 — Sat, 17 Feb 2024 09:37:48 +0000

Introduction
One of the most effective recipes for solving Dynamic Programming problems is Memoization.
Memoization is the process of storing the result of the subproblem and calling them again when a similar subproblem is to be solved. This will reduce the time complexity of the problem. If we do not use memorization, similar subproblems are repeatedly solved which can lead to exponential time complexities.

Memorization has one major advantage over conventional computation techniques: it can drastically cut down on the time and resources needed to compute a function’s output. This is especially helpful when dealing with functions that perform repetitive tasks or have a high computational cost. The program can execute more quickly by avoiding the overhead of repeatedly computing the same result by caching the output of these functions.

Memoization is useful in various Python programming applications, such as:

Recursive functions that call themselves with the same input values
Computationally intensive functions, such as mathematical functions
Functions that retrieve data from a remote source or database

Factorial
Let's look a simple example if recursion. The example below uses recursion to compute the factorial of a number. eg.(200)

def factorial(input):
    if input < 2: 
        return 1
    elif input >= 2:
        return input * factorial(input-1)

print(factorial(200))

Memoization
Lets look at the same example with Memoization

memo ={}
def memoized(n):
    if n in memo:
        return memo[n]
    elif n == 0:
        return 1
    else:
        x = fact(n-1) * n
        memo[n] = x
        return x
print(memoized(200))

Drilling in React

ckorley4 — Fri, 26 Jan 2024 20:47:47 +0000

Props are used by react to pass information from one component to another

There are situations that require information to go from Parent component to child component and to Grandchildren

How to avoid prop drilling
In case, when you project become larger and more complex, prop drilling can become a problem. To avoid this problem in React-based projects, there are several patterns and techniques that can be used:

React Context
React Context is a way to share data across the component hierarchy without passing it down explicitly as props. Context can be a good alternative to prop drilling when you need to share data across multiple components.
The problem with Prop Drilling is that whenever data from the Parent component will be needed, it would have to come from each level, Regardless of the fact that it is not needed there and simply needed in last.

With Context, you can define data at the top level of the component tree and then access it anywhere in the tree. This can help reduce the amount of code you need to write, and make it easier to manage and share data across the component hierarchy.

Drawbacks of Drilling
Code Complexity
As components grow, prop drilling increases code complexity as it is difficult to track the flow of data through various components.
Reduced Maintainability
It will become very challenging to maintain the code with prop drilling. When changes are required in the data flow, you need to make changes in many components.

Performance Overhead We have to pass props through unnecessary intermediary components which can impact performance.

Decreased Component Reusability
Components used in prop drilling become tightly coupled to the structure of the parent components, so it very difficult to use it on other parts of the application.
Increased Development Time: Prop drilling often requires additional planning to implement. This can slow down the development process, especially when the component hierarchies is complex.

A better alternative to this is using useContext hook. The useContext hook is based on Context API and works on the mechanism of Provider and Consumer. Provider needs to wrap components inside Provider Components in which data have to be consumed. Then in those components, using the useContext hook that data needs to be consumed.

Resources
https://www.geeksforgeeks.org/what-is-prop-drilling-and-how-to-avoid-it/
https://javascript.plainenglish.io/prop-drilling-in-react-understanding-the-benefits-and-pitfalls-of-passing-props-down-the-component-fcf9887f8b73

Recursion, A Beginner's guide

ckorley4 — Wed, 10 Jan 2024 14:23:52 +0000

Intronduction
Recursion is used to solve problems that contain smaller sub-problems.When a function calls itself, recusion has occurred. A recursive function can receive two inputs: a base case (ends recursion) or a recursive case (resumes recursion).

Lets look at an example of traversing a complex object

const userInfo = {
  came: 'Thomas',
  school: {
    name: 'Flat Schools',
    jobTitle: 'Developer',
  },
  friends: [
    {
     name: 'Ama',
      school: {
        name: 'Carlifornia Low',
        jobTitle: 'Programmer',
      },
    },
    {
      name: 'Nii',
      school: {
        name: 'New York High',
        jobTitle: 'Lead Developer',
      },
    },
  ],
  assignments: [
    {
      title: 'Draw',
      description:
        'Draw the map of the world.',
    },
    {
      title: 'Paint',
      description:
        'Paint a statue in your neighborhood.',
    },
  ],
}

Traversing the userInfo Object with a recursive function requires the Base case and the Recursive case.

function resursionExample(object) {
  if (typeof object === 'object') {
    for (const key in object) {
      deepIterator(object[key])
    }
  } else {
    console.log(object)
  }
}

Base Case
The base case of a recursive function returns a value without performing a recursive call.

else {
    console.log(object)
  }

Recursive case

function resursionExample(object) {
  if (typeof object === 'object') {
    for (const key in object) {
      deepIterator(object[key])
    }

Recursion Pitfalls
A common pitfall when designing recursive algorithms include not defining a base case.This will lead to causing infinite recursion, and inefficient memory usage.

Recursive algorithms can be less efficient than their iterative counterparts. This is because each recursive call involves overhead, such as saving the state of the current function and setting up the new function. In contrast, iterative algorithms use a loop to repeat operations, which can be faster and use less memory.

Conclusion
Recursive function may be easier to write and reduces unnecessary function calling.
Despite these benefits Recursive functions are generally slower than non-recursive function and may require a lot of memory space to hold intermediate results on the system stacks.
The programmer must evaluate a problem thoroughly before choose to write a recursive function

References
https://developer.mozilla.org/en-US/docs/Glossary/Recursion
https://www.tutorchase.com/answers/ib/computer-science/what-are-common-pitfalls-when-designing-recursive-algorithms
https://www.archilovers.com/stories/5232/the-8-most-extraordinary-spiral-staircases-found-around-the-world.html
https://www.collegenote.net/curriculum/data-structures-and-algorithms/41/454/