Understanding and Implementing Schemas in Python

-
Understanding and Implementing Schemas in Python Introduction In the world of programming, particularly in the context of data management and validation, schemas play a vital role. A schema is essentially a blueprint or a predefined structure that defines the expected format, data types, and constraints for a given data entity. In this blog, we will delve into the concept of schemas in Python, exploring what they are, why they are important, and how you can implement them in your projects. What is a Schema? A schema serves as a contract between different components of a system, ensuring that data is consistent, valid, and well-structured. It defines the rules for how data should be organized, what fields it should contain, and what types of values those fields can hold. In essence, a schema acts as a set of rules that data must adhere to in order to be considered valid. Why Are Schemas Important? Data Validation: Schemas provide a way to validate incoming data. When data is received o...
Post a Comment

Collection Modules in Python

-

Collection Modules in Python 


Python is a powerful programming language that offers a wide range of built-in data types, including lists, tuples, sets, and dictionaries. However, sometimes these data types may not be enough to solve a particular problem. This is where the collections module comes in handy.

The collections module is a built-in module in Python that provides alternatives to the built-in data types. It contains several container data types, which are more specialized than the built-in data types, making them more efficient and convenient to use in certain situations.

In this blog, we will explore some of the container data types provided by the collections module and see how they can be used to solve specific problems.

Counter

The Counter is a dictionary subclass that helps count the occurrences of elements in a sequence. It takes an iterable (e.g., a list or a string) as an argument and returns a dictionary with the elements of the iterable as keys and their counts as values. Here's an example:

from collections import Counter my_list = ['a', 'b', 'c', 'a', 'a', 'b', 'd'] my_counter = Counter(my_list) print(my_counter) # Counter({'a': 3, 'b': 2, 'c': 1, 'd': 1})

In the example above, we created a Counter object from a list of strings. The resulting Counter object contains a count of the occurrences of each element in the list.

DefaultDict

The defaultdict is a dictionary subclass that provides a default value for keys that do not exist. It takes a factory function as an argument that returns the default value. Here's an example:

from collections import defaultdict my_dict = defaultdict(int) my_dict['a'] += 1 my_dict['b'] += 1 print(my_dict) # defaultdict(<class 'int'>, {'a': 1, 'b': 1})

In the example above, we created a defaultdict object with the factory function int(), which returns 0. When we accessed the keys 'a' and 'b', which did not exist in the dictionary, the defaultdict automatically created them with the default value of 0. We then incremented the values of the keys, and the dictionary was updated accordingly.

NamedTuple

The NamedTuple is a factory function for creating tuple subclasses with named fields. It takes a type name and a list of field names as arguments and returns a new class that can be used to create instances of the named tuple. Here's an example:

from collections import namedtuple Person = namedtuple('Person', ['name', 'age', 'gender']) p1 = Person('Alice', 30, 'female') p2 = Person('Bob', 25, 'male') print(p1.name, p1.age, p1.gender) # Alice 30 female print(p2.name, p2.age, p2.gender) # Bob 25 male

In the example above, we created a named tuple class called Person with three fields: name, age, and gender. We then created two instances of the Person class and accessed their fields using dot notation.

OrderedDict

OrderedDict is a class in the Python standard library's collections module that is a subclass of the built-in dict class. The key difference between a regular dict and an OrderedDict is that OrderedDict remembers the order in which key-value pairs were added. In a regular dict, the order of key-value pairs is not guaranteed.

Here's an example of how to use OrderedDict:

from collections import OrderedDict # Create an empty ordered dictionary od = OrderedDict() # Add key-value pairs in a specific order od['a'] = 1 od['b'] = 2 od['c'] = 3 # Print the ordered dictionary print(od) # Output: OrderedDict([('a', 1), ('b', 2), ('c', 3)]) # Iterate over the ordered dictionary for key, value in od.items(): print(key, value) # Output: # a 1 # b 2 # c 3

Note that in the example above, the order in which the key-value pairs were added to the OrderedDict is preserved when the dictionary is printed and iterated over. This can be useful in situations where the order of the items in the dictionary is important, such as when you need to process data in a specific order.

ChainMap

ChainMap is a class in Python's collections module that provides a way to combine multiple dictionaries or mappings into a single view. It is used to search through multiple dictionaries in a single step.

Here's an example of how to use ChainMap:

from collections import ChainMap # Create two dictionaries dict1 = {'a': 1, 'b': 2} dict2 = {'b': 3, 'c': 4} # Create a ChainMap chain = ChainMap(dict1, dict2) # Access keys and values in the ChainMap print(chain['a']) # Output: 1 print(chain['b']) # Output: 2 (from dict1) print(chain['c']) # Output: 4 (from dict2) # Iterate over the ChainMap for key, value in chain.items(): print(key, value) # Output: # a 1 # b 2 # c 4

In the example above, we create two dictionaries dict1 and dict2, and then create a ChainMap chain by passing these two dictionaries as arguments. When we access a key in the ChainMap, it searches through the dictionaries in the order they were passed to the ChainMap constructor, and returns the first value it finds. In this case, chain['b'] returns the value 2 from dict1, because it was the first dictionary in the ChainMap that contained the key 'b'.

The ChainMap is particularly useful when you have a hierarchy of dictionaries, and you want to search through all of them in a specific order. It allows you to treat multiple dictionaries as a single entity, and provides a convenient way to access and manipulate their contents.

UserDict

UserDict is a built-in Python class in the collections module that is a wrapper around the built-in dict class. It is designed to be subclassed, and provides a way to create custom dictionary-like objects.

One advantage of using UserDict over directly subclassing dict is that it avoids recursion when you try to modify the dictionary inside a special method like __getitem__() or __setitem__(). This is because the special methods of UserDict use the non-overridden methods of the underlying dict to perform their operations.

Here's an example of how to use UserDict:

from collections import UserDict # Create a custom dictionary class MyDict(UserDict): def __setitem__(self, key, value): super().__setitem__(key, value * 2) # Create an instance of the custom dictionary d = MyDict() # Add a key-value pair d['a'] = 1 # Print the dictionary print(d) # Output: {'a': 2} # Add another key-value pair d['b'] = 2 # Print the dictionary again print(d) # Output: {'a': 2, 'b': 4}

In the example above, we define a custom dictionary class MyDict that subclasses UserDict. We override the __setitem__() method to multiply the value by 2 before calling the superclass implementation. When we create an instance of MyDict and add key-value pairs to it, the overridden __setitem__() method is called automatically, and the values are multiplied by 2 before being stored in the dictionary.

UserDict provides a simple way to create dictionary-like objects with custom behavior, without having to worry about recursion and other implementation details.

UserList

UserList is a built-in Python class in the collections module that is a wrapper around a standard Python list. It is designed to be subclassed, and provides a way to create custom list-like objects.

One advantage of using UserList over directly subclassing a standard list is that it avoids some of the issues that can arise when subclassing built-in types in Python. For example, when you subclass a list, the overridden methods of the subclass will not automatically return instances of the subclass. But when you subclass UserList, the overridden methods will return instances of the subclass.

Here's an example of how to use UserList:

from collections import UserList # Create a custom list class MyList(UserList): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.square_values() def square_values(self): self.data = [x ** 2 for x in self.data] # Create an instance of the custom list l = MyList([1, 2, 3]) # Print the list print(l) # Output: [1, 4, 9]

In the example above, we define a custom list class MyList that subclasses UserList. We override the __init__() method to call the superclass implementation and then square the values in the list using a custom method square_values(). When we create an instance of MyList and pass in [1, 2, 3] as an argument, the overridden __init__() method is called automatically, and the values in the list are squared before being stored in the list.

UserList provides a simple way to create list-like objects with custom behavior, without having to worry about some of the issues that can arise when subclassing built-in types in Python.

UserString


UserString is a built-in Python class in the collections module that is a wrapper around a standard Python string. It is designed to be subclassed, and provides a way to create custom string-like objects.

One advantage of using UserString over directly subclassing a standard string is that it avoids some of the issues that can arise when subclassing built-in types in Python. For example, when you subclass a string, the overridden methods of the subclass will not automatically return instances of the subclass. But when you subclass UserString, the overridden methods will return instances of the subclass.

Here's an example of how to use UserString:

from collections import UserString # Create a custom string class MyString(UserString): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.reverse() def reverse(self): self.data = self.data[::-1] # Create an instance of the custom string s = MyString('hello') # Print the string print(s) # Output: olleh

In the example above, we define a custom string class MyString that subclasses UserString. We override the __init__() method to call the superclass implementation and then reverse the string using a custom method reverse(). When we create an instance of MyString and pass in 'hello' as an argument, the overridden __init__() method is called automatically, and the string is reversed before being stored in the data attribute of the UserString object.

UserString provides a simple way to create string-like objects with custom behavior, without having to worry about some of the issues that can arise when subclassing built-in types in Python.

DeQue

deque (pronounced "deck") is a built-in Python class in the collections module that provides a double-ended queue, which is a data structure that allows adding and removing elements from both ends with O(1) complexity. deque objects are similar to lists, but with optimized methods for adding and removing elements from the beginning and end of the queue.

Here's an example of how to use deque:

from collections import deque # Create a deque object d = deque() # Add elements to the deque d.append('a') d.append('b') d.append('c') # Print the deque print(d) # Output: deque(['a', 'b', 'c']) # Add an element to the beginning of the deque d.appendleft('d') # Print the deque print(d) # Output: deque(['d', 'a', 'b', 'c']) # Remove an element from the end of the deque d.pop() # Print the deque print(d) # Output: deque(['d', 'a', 'b']) # Remove an element from the beginning of the deque d.popleft() # Print the deque print(d) # Output: deque(['a', 'b'])

In the example above, we create a deque object d and add elements to it using the append() method. We then add an element to the beginning of the deque using the appendleft() method, and remove elements from the end and beginning of the deque using the pop() and popleft() methods, respectively.

deque objects can be a useful data structure for implementing algorithms that require adding and removing elements from both ends of a list with efficient time complexity.


Happy Learning!! Happy Coding!!

Comments

New comments are not allowed.

Popular posts from this blog

useNavigate and useLocation hooks react-router-dom-v6

-
Image
useNavigate and useLocation hooks - Navigating programmatically to a route. In this post, we will learn about two new hooks from react-router-dom version 6 library. 1) useNavigate - Let’s say on click of a button, If you want to perform redirection to the page, then react router provide us with a hook called as useNavigate. - useNavigate hook replaced useHistory hook, but it works same as useHistory but in addition it has good feature. - useNavigate hook is only available in react-router-dom version 6. - We can redirect to Previous and Next page with the help of useNavigate hooks.  2) useLocation - We required two library React 16.8+ and react-router-dom 5.1+ for useLocation hook. - It is a function that returns the location object that contains information about the current URL. - New location object is created, whenever the URL changed. useNavigate and useLocation hooks react router dom version 6Js and Xstate Install React Router Command npm install react-router-dom --save Sample...
Read more

Localization in React Js

-
Image
Localization in React Js using react-localization package. In this post, we will learn about Localization in React Js. Now a day, Localization is very important and basic requirement in every web based application. Following source code will help you, creating a multilingual Web application in React Js. Note: Use Double Click for Radio Boxes. Localization in React Js Installation: npm install --save react-localization Folder Structure: Sample Code A) index.js import   React   from   "react" ; import   ReactDOM   from   "react-dom" ; import   App   from   "./App" ; ReactDOM . render ( < App   /> ,  document . getElementById ( "root" )); B) App.js ( Class Component ) import   React , {  Component  }  from   'react' ; import   labels   from   './Local/localize' ; import   './style.css' ; class   App   extends   Component  {    constructor ( props )...
Read more

How to implement error boundaries in React Js

-
Error boundaries in React Js In this post, we will learn about "Error Boundaries in React Js". First of all, why we required Error Boundaries? This is the first question comes in my mind, as before React 16, we don't have any mechanism to catch error inside components and because of which whole app in broken state on next renders. No ways to handle these errors in React Components, nor it gives any methods to recover from them. React 16 introduces a new concept to handle such errors by using the error boundaries. So now, if any error found in a part of the UI, it does not break the whole application. According to official document of React Js, There are following few areas in application, where error boundaries are not suitable solution. a) Event handlers b) Asynchronous code (e.g., setTimeout) c) Server-side rendering d) Errors are thrown in the error boundary itself  For complex application which contains multiple components, we can declare multiple error boundaries to ...
Read more

Pass data from child component to its parent component in React Js

-
Image
Pass data from child component to its parent component in React Js In this post, we will learn about how to pass data from child component to its parent component in React js. We need to do following steps to pass/send data from child component to parent component: a) In the parent component, create a callback function. This callback function is useful to retrieve the data from the child component. b) Pass the callback function to the child as a props from the parent component. c) The child component calls the parent callback function using props and sends the data to the parent component. Send data from child component to its parent component Sample Code: A) index.js import   React   from   "react" ; import   ReactDOM   from   "react-dom" ; import   App   from   "./App" ; ReactDOM . render ( < App   /> ,  document . getElementById ( "root" )); B) App.js import   React , {  useState  }  from   're...
Read more

Create a Shopping Item App using React Js and Xstate

-
Image
Create a Shopping Item App using React Js and Xstate ( state management )  In this post, we will create a shopping item app using React js and Xstate. Generally, we use redux for state management but in this application, I am going to show you state management with the help of Xstate. Shopping Item App using React Js and Xstate Dependency:   npm install xstate @xstate/react Folder Structure: Sample Code: A) index.js import   React   from   "react" ; import   ReactDOM   from   "react-dom" ; import   App   from   "./App" ; ReactDOM . render ( < App   /> ,  document . getElementById ( "root" )); B) App.js import   React   from   'react' ; import   Product   from   './Product/Product' ; import   './style.css' ; import  { ShoppingContext ,  ShoppingMachine }  from   './State/index' import  {  useMachine  }  from   '@xstate/react' ; export ...
Read more

How to fetch data using Axios Http Get Request in React Js?

-
Image
How to fetch data using  Axios - Http Get Request in React Js? In one of my previous post, I had explained all about Fetch() method to retrieve data from api server. In this post, I am going to demystify how to achieve same thing using axios. Axios has many advantages over fetch() method. 1) Axios has the ability to intercept HTTP request. 2) With axios.all() method, you can make simultaneous requests, simply send an array of request to this method, then use axios.spread() method to assign the properties of the response array to separate varialbes. 3) Axios automatically stringifies the data when sending requests, as in fetch() method, you would have to do it manually. 4) You can set response timeout. 5) Support backward compatibility, this is because it uses XMLhttprequest under the hood.  Fetch User Data Using Axios - Get Request Installation: npm install axios or yarn add axios Sample Code: A) index.js import   React   from   "react" ; import   ReactDOM...
Read more

How to fetch data from an API using fetch() method in React Js

-
Image
How to fetch data from an API using fetch() method in React Js? Now a day, we can't imagine web application without API so one of the basic requirement of any web application is to communicate with servers through HTTP protocol. This can be easily done using Fetch and Axios .  In this post, we are mainly focusing on Fetch. The Fetch API provides a fetch() method defined on the window object. The fetch method has one mandatory argument i.e., URL of the resource to be fetched. This method returns promise object that can be used to retrieve response of the request.  There are following limitations of Fetch API: a) Fetch does not allows cancelling request and request timeout. b) Fetch does not provide a way to intercept HTTP requests. c) Fetch has no url in request object. d) No installation is required. e) Fetch does not have XSRF protection. f) Fetch uses the body property. g) Fetch is a two step process when handling JSON data, first - to make actual request. second - to call j...
Read more

Create a ToDo App in React Js | Interview Question

-
Image
Create a ToDo App in React Js | Interview Question In this post, you will learn about how to create To-Do App in React using hooks. I have use arrays of object to save to do list, not redux and required some basic packages like Node and npm. Following is the UI functionality of the application. Todo App in React Js Componets:     There are four component created in our application.    a) ToDoHeader: Created for showing details of Header section.    b) AddToItem: Created for adding text to "ToDo list".    c) AddToDoList: Created for showing "ToDo list".    d) ToDoFooter: Created for showing details of Footer section. Sample Code: 1) App.js import   React , {  useState  }  from   'react' ; import   './style.css' ; window . id  =  0 ; const   ToDoHeader  = ()  =>  {    return   < div   id = "todoHeader" >  To Do Applica...
Read more

Routing in React using React-Router Version 6

-
Image
 Routing in React using React-Router Version 6 What is Routing? - The process of navigating a user to different pages based on their request is known as routing. - Routing is a process of binding a web URL to specific resource. In react we can say, "it is a binding of URL to a specific component. - As react is a user interface library, it does not support routing. - In this post, we will learn about "routing in react using  react-router-dom  library version 6". Install React Router Command npm install react-router-dom --save Main component used for Navigation 1) BrowserRouter as Router - top level component  2) Routes - Replacement of Switch component. 3) Route - child component of Routes, useful for mapping a specific URL to a component. 4) Link - Similar to anchor tag in html. Note:  Switch Component is deprecated from version 6. The new component is introduced called as  Routes . Multiple Routing in React Js Installation:  npm install react-router-d...
Read more

Auto Increment, Decrement, Reset and Pause counter in React Js | Interview Question

-
Image
Auto Increment, Decrement, Reset & Pause counter in React Js | Interview Question In this post, I am going to cover one interview question & following is the functionality of the application. I hope you may have come across such situation especially in react interview. Counter in React Js There are four functionality covered in the application: A) Increment B) Decrement C) Reset D) Pause Sample Code: A) App.js import   React , {  useState ,  useEffect  }  from   'react' ; import   './style.css' ; export   default   function   App () {    const  [ count ,  setCount ] =  useState ( 0 );    const  [ action ,  setAction ] =  useState ( false );    const  [ operation ,  setOperation ] =  useState ( '' );    useEffect (()  =>  {      if  ( action ) {      ...
Read more