DEV Community: Sona

Unlock the power of effortless testing with PyTest—learn to write, execute, and automate your Python tests with ease!

Sona — Tue, 24 Sep 2024 05:36:59 +0000

Dive into this guide for hands-on examples and expert insights.

PyTest is one of the most widely used testing frameworks for Python. Its simplicity, ease of use, and powerful capabilities make it ideal for both beginners and advanced users. This article will guide you through the core concepts of PyTest with detailed examples to help you understand how to write, execute, and manage your tests.

Why Use PyTest?
PyTest provides:

Simple syntax to write tests
Supports fixtures for code reuse
Assertions with detailed failure messages
Built-in support for parameterized testing
Plugins to extend functionality
Installation
To install PyTest, run the following command:

pip install pytest

Writing Your First Test
A basic test in PyTest is a function whose name starts with test_. PyTest will automatically discover and execute all such functions.

Example 1: A Simple Test Case

# test_sample.py

def test_addition():
    assert 1 + 2 == 3  # This will pass

Explanation:
In the above example, the function test_addition contains an assertion that checks if 1 + 2 equals 3. If the assertion is correct, the test will pass.

To run this test, execute:
pytest test_sample.py

PyTest will automatically discover and run the test case.

BGR Color Palette with Trackbars Using Python and OpenCV

Sona — Mon, 23 Sep 2024 08:47:29 +0000

BGR Color Palette with Trackbars Using Python and OpenCV. OpenCV (Open Source Computer Vision Library) is a popular library designed for real-time computer vision tasks. It offers various functions to work with images and videos, making it an essential tool in computer vision applications.

In this tutorial, we will create an interactive RGB color palette with trackbars using OpenCV in Python. By adjusting these trackbars, the RGB values will change dynamically between 0 and 255, allowing you to experiment and find the exact color represented by those RGB values.

Required Libraries:
To build this RGB color palette, we will need the following libraries:

OpenCV: For creating the window, trackbars, and capturing RGB values.
NumPy: For handling arrays and creating a blank image (black window) where the colors will be displayed.
Approach:
We will create a blank black window with a resolution of 512×512 pixels and three color channels (Blue, Green, and Red). Using OpenCV’s built-in functions, we will set up trackbars to control the intensity of each color channel (BGR).

The range for these trackbars will be from 0 to 255, allowing for the full spectrum of color values. As we move the trackbars, the RGB values will update in real-time, and the black window will change to reflect the new color.

Steps:
Create a Blank Black Window: Using NumPy, we will initialize a black window of 512×512 pixels, where each pixel has three channels for B, G, and R.
Set Up Trackbars: With OpenCV’s createTrackbar() function, we will create three trackbars to control the Blue, Green, and Red color channels. These trackbars will allow the user to adjust the intensity of each color component.
Update the Window in Real-Time: The values from the trackbars will be captured using getTrackbarPos() and used to modify the color displayed in the black window. Each time a trackbar is moved, the window will update to display the corresponding color based on the RGB values.
Here’s the full Python code for this project:

# Importing required libraries
import cv2
import numpy as np

# Define an empty function to handle trackbar events
def emptyFunction():
    pass

def main():
    # Create a blank black image of size 512x512 pixels with 3 color channels (B, G, R)
    image = np.zeros((512, 512, 3), np.uint8)  
    windowName = "OpenCV Color Palette"

    # Create a window with the specified name
    cv2.namedWindow(windowName)

    # Create trackbars for Blue, Green, and Red colors
    # The trackbars range from 0 to 255, representing the color intensity
    cv2.createTrackbar('Blue', windowName, 0, 255, emptyFunction)
    cv2.createTrackbar('Green', windowName, 0, 255, emptyFunction)
    cv2.createTrackbar('Red', windowName, 0, 255, emptyFunction)

    # Infinite loop to keep the window open until the ESC key is pressed
    while True:
        # Display the current image in the window
        cv2.imshow(windowName, image)

        # Exit the loop when the ESC key is pressed (ASCII value 27)
        if cv2.waitKey(1) == 27:
            break

        # Get the current positions of the trackbars
        blue = cv2.getTrackbarPos('Blue', windowName)
        green = cv2.getTrackbarPos('Green', windowName)
        red = cv2.getTrackbarPos('Red', windowName)

        # Update the image by filling it with the new color values from the trackbars
        image[:] = [blue, green, red]

        # Print the current RGB values to the console
        print(blue, green, red)

    # Close all windows when the loop is terminated
    cv2.destroyAllWindows()

# Calling the main function
if __name__ == "__main__":
    main()

Read More Below

Table Creation Made Easy: Using Tkinter in Python

Sona — Thu, 19 Sep 2024 09:37:14 +0000

Python provides several options for developing graphical user interfaces (GUIs), with Tkinter being the most popular choice. Tkinter serves as the standard Python interface to the Tk GUI toolkit, which comes included with Python installations. It’s the quickest and easiest way to build GUI applications. Creating a GUI with Tkinter is straightforward and user-friendly.

Creating Tables Using Tkinter

Tables are useful for organizing data into rows and columns. While Tkinter does not include a dedicated Table widget, we can create tables using alternative methods. For instance, we can arrange Entry widgets in a grid format to simulate a table.

To create a table with five rows and four columns, we can utilize nested for loops as follows:

for i in range(5): for j in range(4):

Inside these loops, we have to create an Entry widget by creating an object of Entry class, as:

e = Entry(root, width=20, fg='blue', font=('Arial', 16, 'bold')

Next, we need to implement the logic for positioning the Entry widgets in rows and columns. This can be achieved using the grid() method, where we specify the row and column indices for each widget, as follows:

`# here i and j indicate

row and column positions

e.grid(row=i, column=j)`

We can insert data into the Entry widget using insert() method, as:

e.insert(END, data)

In this context, ‘END’ signifies that new data will be appended to the end of the existing content in the Entry widget. The following program demonstrates this logic by using data from a list.

We have created a list containing five tuples, where each tuple includes four values representing a student’s ID, name, city, and age. As a result, we will have a table with five rows and four columns. This approach can also be adapted to display data retrieved from a database in a tabular format.

Let’s us check out the full code:

`# Python program to create a table

from tkinter import *

class Table:

def init(self,root):

# code for creating table
for i in range(total_rows):
    for j in range(total_columns):

        self.e = Entry(root, width=20, fg='blue',
                    font=('Arial',16,'bold'))

        self.e.grid(row=i, column=j)
        self.e.insert(END, lst[i][j])

take the data

lst = [(1,'Rajesh','Delhi',19),
(2,'Paul','United kingdom',18),
(3,'Sonia','Mumbai',20),
(4,'Rachna','Hyderabad',21),
(5,'Dunccan','New york',21)]

find total number of rows and

columns in list

total_rows = len(lst)
total_columns = len(lst[0])

create root window

root = Tk()
t = Table(root)
root.mainloop()`

Check out the full output below

Unlock seamless file sharing with your own Python app

Sona — Wed, 18 Sep 2024 12:02:11 +0000

Computer Networks is a vital topic in computer science, and grasping its concepts often requires practical application. In this article, we will guide you through the process of creating a simple file-sharing application using Python. This project will not only reinforce your understanding of networking principles but also provide hands-on experience with relevant Python modules.

What is an HTTP Web Server?
An HTTP Web Server is software that understands URLs (web addresses) and the HTTP protocol, which is the foundation for viewing webpages. Python offers several packages that include a collection of modules to facilitate network programming, as well as built-in servers that simplify the development of web applications.

Key Modules Used in This Project
HTTPServer: This module, part of the socketserver package, creates and listens on the HTTP socket. It is essential for handling HTTP requests.
Socketserver: This module simplifies the task of writing network servers, making it easier to create custom server functionalities.
Webbrowser: This high-level interface allows us to open web-based documents easily by calling the open() function.
PyQRCode: This module enables us to generate QR codes with just a couple of lines of code, providing a quick way to share information.
OS Module: This module facilitates interaction with the operating system. It is used for opening files, manipulating paths, and reading files directly from the command line.
PyPNG: This library allows for the reading and writing of PNG image files using pure Python, which is useful for handling QR codes in image format.
Step-by-Step Approach
Here’s a detailed outline of the steps involved in creating the file-sharing app:

Install Required Modules: Begin by installing the necessary third-party modules via the command line:

pip install pyqrcode pip install pypng

Import Necessary Modules: Import the following modules at the beginning of your Python script:

`# import necessary modules

for implementing the HTTP Web servers

import http.server

provides access to the BSD socket interface

import socket

a framework for network servers

import socketserver

to display a Web-based documents to users

import webbrowser

to generate qrcode

import pyqrcode
from pyqrcode import QRCode

convert into png format

import png

to access operating system control

import os

assigning the appropriate port value

PORT = 8010

this finds the name of the computer user

os.environ['USERPROFILE']

changing the directory to access the files desktop

with the help of os module

desktop = os.path.join(os.path.join(os.environ['USERPROFILE']),
'OneDrive')
os.chdir(desktop)

creating a http request

Handler = http.server.SimpleHTTPRequestHandler

returns, host name of the system under

which Python interpreter is executed

hostname = socket.gethostname()

finding the IP address of the PC

s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(("8.8.8.8", 80))
IP = "http://" + s.getsockname()[0] + ":" + str(PORT)
link = IP

converting the IP address into the form of a QRcode

with the help of pyqrcode module

converts the IP address into a Qrcode

url = pyqrcode.create(link)

saves the Qrcode inform of svg

url.svg("myqr.svg", scale=8)

opens the Qrcode image in the web browser

webbrowser.open('myqr.svg')

Creating the HTTP request and serving the

folder in the PORT 8010,and the pyqrcode is generated

continuous stream of data between client and server

with socketserver.TCPServer(("", PORT), Handler) as httpd:
print("serving at port", PORT)
print("Type this in your Browser", IP)
print("or Use the QRCode")
httpd.serve_forever()`

Output:

Open the python file which has the above code on PC.
This will generate a QR-code.
Either Scan the QR-code or type the IP Address shown in the python shell in your mobile browser.
Share the files with ease by scanning the QR-code that’s generated and get access to the files in PC, from the mobile browser.

Read More Here

secrets to pristine Python programming with our essential guide

Sona — Mon, 16 Sep 2024 05:17:44 +0000

Elevate your coding game and master the art of elegant solutions! #python

Essential Best Practices for Clean and Efficient Python Code Python has become one of the most popular programming languages in the world, surpassing even Java in terms of usage and study. Today, it ranks as the second most popular language after JavaScript and continues to gain ground rapidly.

Python’s versatility is reflected in its extensive applications across various fields, including web development with frameworks like Django and Flask, web scraping, automation, system administration, DevOps, network programming, testing, data analysis, data science, machine learning, and artificial intelligence. It’s often the go-to language for data-related technologies.

Best Practices for Writing Clean Python Code

Python is highly favored by beginners due to its ease of learning, extensive community support, and comprehensive documentation. However, transitioning from languages like Java, C, C++, or JavaScript to Python can pose challenges, particularly when it comes to adhering to best practices for writing clean code. Clean code is crucial as it enhances readability, simplifies debugging, and contributes to overall code elegance. Let’s delve into some of the essential practices to achieve clean Python code.

Effective Documentation

Incorporating clear and readable comments is fundamental for maintaining comprehensible code. Even complex programs can be made more understandable with well-placed comments. There are two main types of comments in Python:

Single Line Comments: These comments are used for brief explanations and are preceded by a hash symbol (#). They extend to the end of the line.
Multi-line Comments: These comments are useful for elaborating on larger blocks of code. They are enclosed in triple quotes (”’ or “””) and can also be used to define string literals. For extensive commentary, it’s generally better to use hash symbols for each line to avoid potential issues with string-based comments.
For more details on comments, see: Comments in Python.

Consistent Indentation

Unlike languages such as C++ or Java, Python uses indentation to define code blocks instead of braces. Indentation must be consistent throughout your code, using either spaces or tabs uniformly. Inconsistent indentation can lead to errors or misinterpretations of code structure. Here are examples demonstrating correct indentation:

If-Else Statement:
`if condition1:
# Code to execute if condition1 is True
else:
# Code to execute if condition1 is False

For Loop with Nested If-Else:

To learn more about indentation, must read: Indentation in Python

for i in sequence: if condition1: # Code for the outer if block if condition2: # Code for the nested if block else: # Code for the outer else block`

https://codemagnet.in/2024/09/16/essential-best-practices-for-clean-and-efficient-python-code/

Powerful llist module—your key to efficient data manipulation

Sona — Mon, 16 Sep 2024 05:15:56 +0000

Master the art of linked lists in Python with the powerful llist module—your key to efficient data manipulation. Unlock speed and flexibility in list management with this developer-friendly guide! #python

Python llist module: A Step-by-Step Guide for Developers. For a long time, Python did not have a built-in way to implement the linked list data structure. Although Python supports lists, they have limitations when used in scenarios requiring the dynamic nature of a linked list.

A standard Python list is rigid because its elements are stored in contiguous memory locations, which are not connected by pointers. This leads to inefficiencies, such as wasting memory space when the list is not fully filled, as it reserves a defined block of memory.

To address some of these issues, Python’s deque (double-ended queue) data structure has been used as a substitute to function like a linked list. However, the deque structure also has limitations, especially in terms of flexibility and speed.

To overcome these challenges, Python now has the llist module, which is specifically designed to provide an efficient and functional linked list implementation.

The llist Module in Python
The llist module is a powerful extension for CPython that introduces a fundamental linked list structure. It offers a more efficient solution for linked list operations than Python’s built-in list and even the deque. The llist module is optimized for speed and is significantly faster than both deque and list when it comes to managing linked list operations.

Installation
To use the llist module, you need to install it, just like any other Python extension or package. You can install it using pip with the following command:

pip install llist

Alternatively, if you prefer manual installation, you can download the package from the Python Package Index (PyPI) at http://pypi.python.org/pypi. After downloading, unpack the resources and compile them using the following command:

python setup.py install

Once installed, you can import the llist module and start using it in your programs.

Methods and Objects Provided by the llist Module
The llist module provides two types of linked list implementations:

Singly Linked List (sllist): A linked list where each node points to the next node in the sequence.
Doubly Linked List (dllist): A linked list where each node contains references to both the previous and the next node, allowing bidirectional traversal.
Objects in the llist Module
dllist: This object implements a doubly linked list.
dllistnode: This creates a new node for a doubly linked list. You can optionally initialize it with data.
dllistiterator: An iterator object to traverse through a doubly linked list.
sllist: This object implements a singly linked list.
sllistnode: A node for a singly linked list, optionally initialized with data.
sllistiterator: An iterator object to traverse through a singly linked list.
Explanation of Linked Lists in the llist Module
Singly Linked List (sllist): Each node in a singly linked list points only to the next node in the sequence. This means you can traverse the list in a single direction. The head node points to the next node, and so on, until you reach the end, where the last node’s pointer is None.
Doubly Linked List (dllist): Each node in a doubly linked list contains two pointers: one to the next node and one to the previous node. This allows traversal in both directions, making it more flexible than a singly linked list, especially when you need to navigate back and forth through the list.
These linked list structures are extremely useful when you need to manage dynamic data collections where elements are frequently added or removed. They provide more memory-efficient solutions compared to standard Python lists, especially in scenarios where there are unpredictable amounts of data, and memory conservation is essential.

The following examples will help clarify how the llist module works by demonstrating the basic operations for the two types of lists it supports. Here’s an example using the sllist (singly linked list) to illustrate how to create, manipulate, and manage linked lists in Python:

Example 1: Singly Linked List (sllist)

`# Importing the required packages
import llist
from llist import sllist, sllistnode

Creating a singly linked list with initial values

lst = sllist(['first', 'second', 'third'])
print(lst) # Output: sllist with elements 'first', 'second', 'third'
print(lst.first) # Output: First node in the list ('first')
print(lst.last) # Output: Last node in the list ('third')
print(lst.size) # Output: Number of elements in the list (3)
print()

Adding a new element to the end of the list and inserting a value after a specific node

lst.append('fourth') # Adds 'fourth' to the end of the list
node = lst.nodeat(2) # Gets the node at index 2 ('third')
lst.insertafter('fifth', node) # Inserts 'fifth' after the node 'third'
print(lst) # Output: Updated list with 'first', 'second', 'third', 'fifth', 'fourth'
print(lst.first) # Output: First node ('first')
print(lst.last) # Output: Last node ('fourth')
print(lst.size) # Output: Size of the list (5)
print()

Popping a value from the list (removing the last element)

lst.pop() # Removes 'fourth' from the list
print(lst) # Output: List without 'fourth'
print(lst.first) # Output: First node ('first')
print(lst.last) # Output: Last node ('fifth')
print(lst.size) # Output: Size of the list (4)
print()

Removing a specific element from the list

node = lst.nodeat(1) # Gets the node at index 1 ('second')
lst.remove(node) # Removes the 'second' node from the list
print(lst) # Output: List with 'first', 'third', 'fifth'
print(lst.first) # Output: First node ('first')
print(lst.last) # Output: Last node ('fifth')
print(lst.size) # Output: Size of the list (3)
print()`

Explanation:
Creating the List: A singly linked list (sllist) is created with initial values (‘first’, ‘second’, ‘third’). We can print the entire list, its first and last nodes, and the size of the list.
Appending and Inserting Elements: The append() method adds a new element (‘fourth’) to the end of the list. Using insertafter(), we can insert a new node (‘fifth’) after a specified node (‘third’).
Popping Elements: The pop() method removes the last element from the list.
Removing Specific Elements: The remove() method allows us to remove a specific node, such as the second element (‘second’).
This example shows the flexibility of using sllist in the llist module to manage linked lists, allowing efficient insertion, deletion, and access to elements.

Output:

`dllist([first, second, third])
dllistnode(first)
dllistnode(third)
3

dllist([sixth, fifth, seventh, first, second, third, fourth])
dllistnode(sixth)
dllistnode(fourth)
7

dllist([sixth, fifth, seventh, first, second, third])
dllistnode(sixth)
dllistnode(third)
6

dllist([sixth, seventh, first, second, third])
dllistnode(sixth)
dllistnode(third)
5`

Read More Below

Turn your Python skills into a lyrical maestro with a sleek GUI that fetches song lyrics at the click of a button

Sona — Fri, 13 Sep 2024 06:11:21 +0000

In this article, we’ll create a Python script to extract song lyrics and integrate it with a GUI application. We’ll use the lyrics-extractor library, which retrieves lyrics by searching various websites based on the song’s name. To begin, you’ll need to install the lyrics-extractor module. You can do this by running the following command in your terminal:

pip install lyrics-extractor

API Key and Engine ID: You need these from Google Custom Search JSON API.
Engine ID: Create a Custom Search Engine (CSE) to obtain your Engine ID here.
Set up your Programmable Search Engine (Google Custom Search Engine) and include links to fetch lyrics. Programmable Search Engine leverages Google’s search technology to locate information based on user queries.You can choose any of the following links to configure your search engine:
Genius
Lyricsted
Lyricsbell
Glamsham
Lyricsoff
Lyricsmint
JSON API: The Custom Search JSON API retrieves and displays results from your Programmable Search Engine. To use this API, you’ll need to create a Programmable Search Engine and obtain an API key (https://developers.google.com/custom-search/v1/overview#api_key).

Approach:
Import the necessary modules:

from lyrics_extractor import SongLyrics

Initialize the SongLyrics class with your Google Custom Search JSON API key and Engine ID:

extract_lyrics = SongLyrics(Your_API_KEY, GCS_ENGINE_ID)

Retrieve the lyrics by passing the song name to the get_lyrics() method:

lyrics = extract_lyrics.get_lyrics("Shape of You")

Get the API KEY and GCS_ENGINE_ID from here

Full Code:

`# importing modules
from lyrics_extractor import SongLyrics

pass the GCS_API_KEY, GCS_ENGINE_ID

extract_lyrics = SongLyrics("GCS_API_KEY","GCS_ENGINE_ID")

extract_lyrics.get_lyrics("Tujhse Naraj Nahi Zindagi Lyrics")`

Unlock the power of Python's property() function

Sona — Wed, 04 Sep 2024 10:35:10 +0000

The Python property() function is a built-in feature that returns an object of the property class and is used to create class properties. This function provides a way to define properties in Python, allowing for controlled access to an object’s attributes. In this article, we will explore how the property() function works in Python.

Syntax of Python property() Function
The property() function is used to create properties within a class.

Syntax:
property(fget, fset, fdel, doc)
Parameters:

fget(): Retrieves the attribute’s value.
fset(): Sets the attribute’s value.
fdel(): Deletes the attribute.
doc(): A string that holds the documentation for the attribute.
Return: The function returns a property object created from the specified getter, setter, and deleter functions.

Notes:

If no arguments are provided, the property() function returns a base property object without a getter, setter, or deleter.
If the doc parameter isn’t provided, the property() function will use the docstring of the getter function.
Understanding the property() Function in Python
The property() function in Python is a built-in tool that allows the creation of special attributes known as properties within a class. Properties enable you to encapsulate access to an attribute and introduce additional logic, such as validation or computation, when the attribute is accessed or modified.
Methods to Create Properties in Python
There are two primary ways to create properties in Python:

Using the property() function:
This method allows you to manually create properties by defining getter, setter, and deleter methods.
Using the @property decorator:
This approach simplifies the process by using decorators to define properties.
Example: Creating a Property with the property() Function
In this example, we use the property() function to define a property within a class. We create a class named Alphabet and define a property called value.

This property controls how the internal attribute _value is accessed and modified by defining custom getter and setter methods.

`# Python program to explain property() function

Alphabet class

class Alphabet:
def init(self, value):
self._value = value

# getting the values

def getValue(self):

    print('Getting value')

    return self._value

  
  
  setting the values


def setValue(self, value):

    print('Setting value to ' + value)

    self._value = value

  
  
  deleting the values


def delValue(self):

    print('Deleting value')

    del self._value

value = property(getValue, setValue, 

                 delValue, )

passing the value

x = Alphabet('Codemagnet')
print(x.value)

x.value = 'CM'

del x.value
`

Output:
Getting value Codemagnet Setting value to CM Deleting value

Using the @property Decorator
Decorators in Python are like add-ons that give extra features to your existing code. The @property decorator is a tool that makes your methods behave like regular attributes of a class.

This technique is part of something called metaprogramming, where one part of the program changes another part during the compile time.

Here’s how it works: when you define a method in your class and use the @property decorator, you’re turning that method into an attribute. This means you can access it like a regular variable, but behind the scenes, Python will call the method to get its value.

If you then define the same method again with a @value.setter or @value.deleter, you’re telling Python how to set or delete that attribute.

In simple terms, using @property lets you control what happens when you get, set, or delete a value in your class, all while making your code look clean and simple.

When you access x.value, Python will automatically know whether you’re trying to get, set, or delete the value and will call the right method for you.

Read More Below

Mastering Python RegEx: Comprehensive Guide with Practical Examples

Sona — Wed, 04 Sep 2024 06:04:02 +0000

Regular Expressions, commonly known as RegEx or RegExp, are a powerful tool for matching patterns in text. They are widely used in programming languages like Python for tasks such as data validation, searching, and string manipulation.

This article provides a detailed exploration of Python’s RegEx capabilities, along with practical coding examples to illustrate their use.

What is a Regular Expression?
A Regular Expression is a sequence of characters that forms a search pattern. It can be used to check if a string contains a specified search pattern or to find and replace strings that match the pattern. In Python, the re module is used to work with regular expressions.

Basic Syntax of Python RegEx
Before diving into examples, it’s essential to understand the basic syntax used in Python RegEx:

.: Matches any character except a newline.
^: Matches the start of a string.
$: Matches the end of a string.
*: Matches 0 or more repetitions of the preceding pattern.
+: Matches 1 or more repetitions of the preceding pattern.
?: Matches 0 or 1 occurrence of the preceding pattern.
{n}: Matches exactly n occurrences of the preceding pattern.
{n,}: Matches n or more occurrences of the preceding pattern.
{n,m}: Matches between n and m occurrences of the preceding pattern.
[]: Matches any one of the characters inside the brackets.
|: Matches either the pattern before or the pattern after the |.
() : Groups patterns.
Importing the re Module
To use RegEx in Python, you need to import the re module, which provides various functions to work with regular expressions.

import re

Common RegEx Functions in Python
The re module provides several functions that allow you to perform operations using regular expressions.

re.search() The re.search() function searches the string for a match and returns the first occurrence.

Example:

`import re

pattern = r"hello"
text = "hello world"
match = re.search(pattern, text)

if match:
print("Match found:", match.group())
else:
print("No match found")

Explanation:
This example searches for the word “hello” in the string “hello world”. If found, it prints the match.

re.findall() The re.findall() function returns a list of all matches found in the string.

Example:

`import re

pattern = r"\d+"
text = "There are 123 apples and 456 oranges."
matches = re.findall(pattern, text)

print("Matches:", matches)`

Explanation:
This example searches for all sequences of digits in the string and returns them as a list.

re.split() The re.split() function splits the string by occurrences of the pattern.

Example:

`import re

pattern = r"\s+"
text = "Split this string into words"
split_text = re.split(pattern, text)

print("Split text:", split_text)`

Read More Below

Moving Object Detection with OpenCv & Imutils

Sona — Wed, 15 May 2024 04:18:51 +0000

Detecting moving objects in a video stream is a key task in many computer vision applications. Using OpenCV and Imutils, we can create a program that analyzes video frames to identify areas where there is motion. This can be useful in surveillance, tracking, and many other fields where detecting motion is important. In this article, we’ll explore how to use these libraries to create a simple motion detection program.

Let’s check out the code below for the same along with the output

you need to first create a file with .py extension and copy the below code and paste it there

import cv2 #image
import time #delay
import imutils #resize

cam = cv2.VideoCapture(0) #cam id
time.sleep(1)

firstFrame=None
area = 500

while True:
    _,img = cam.read() #read frame from camera
    text = "Normal" 
    img = imutils.resize(img, width=500) #resize

    grayImg = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) #color 2 Gray scale image

    gaussianImg = cv2.GaussianBlur(grayImg, (21, 21), 0) #smoothened

    if firstFrame is None:
            firstFrame = gaussianImg #capturing 1st frame on 1st iteration
            continue

    imgDiff = cv2.absdiff(firstFrame, gaussianImg) #absolute diff b/w 1st nd current frame

    threshImg = cv2.threshold(imgDiff, 25, 255, cv2.THRESH_BINARY)[1] #binary

    threshImg = cv2.dilate(threshImg, None, iterations=2)

    cnts = cv2.findContours(threshImg.copy(), cv2.RETR_EXTERNAL,
            cv2.CHAIN_APPROX_SIMPLE)

    cnts = imutils.grab_contours(cnts)
    for c in cnts:
            if cv2.contourArea(c) < area:
                    continue
            (x, y, w, h) = cv2.boundingRect(c)
            cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 2)
            text = "Moving Object detected"
    print(text)
    cv2.putText(img, text, (10, 20),
            cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2)
    cv2.imshow("cameraFeed",img)
    key = cv2.waitKey(1) & 0xFF
    if key == ord("q"):
        break

cam.release()
cv2.destroyAllWindows()

Read More Here

Python SciPy Full Tutorial – In Depth Analysis

Sona — Tue, 30 Apr 2024 03:55:41 +0000

SciPy stands for Scientific Python. It provides more utility functions for optimization, stats and signal processing. Like NumPy, SciPy is open source so we can use it freely.

The most important question is why to use SciPy?

If SciPy uses NumPy underneath, why can we not just use NumPy?

The simplest answer would be SciPy has optimized and added functions that are frequently used in NumPy and Data Science.

How To Install SciPy?

pip install scipy

Now, once scipy is installed you can import it into your file or application from scipy import module statement:

from scipy import constants

Now, that you have imported the scipt module lets take a example and see how this module is used.

Example: We want to find out how many cubic meters are in one liter

`from scipy import constants

print(constants.liter)`

Read More Here

Convert Python Dict to JSON: Full Tutorial For Beginner

Sona — Tue, 16 Apr 2024 04:14:51 +0000

When you’re coding in Python, you often deal with JSON, its a format that is used to store and exchange data. If you’ve worked with APIs, you’ve likely parsed JSON responses before.

JSON is like a dictionary in Python, storing data as key-value pairs, making it easy to understand and work with. Python’s json module helps convert Python dictionaries to JSON strings and vice versa.

In this tutorial, our main focus is on converting python dictionaries to JSON using the json module. Let’s dive into the code!

Now, to convert a Python dictionary to JSON string, you can use the dumps() function from the json module. The dumps() function takes in a Python object and returns the JSON string representation. In practice, however, you’ll need to convert not a single dictionary but a collection such as a list of dictionaries.

Let us take an example.

In this example, we first import the json module. Then, we create a list of dictionaries called data. Next, we use the json.dumps() function to convert the data list into a JSON string. Finally, we print the JSON string to the console.

Read More Here