1.

Write a program to create a list of words from the given string which are
less than size 'A'. Input String: "Python programming language has lot of
applications in data analytics". Input = 8

Certainly! Here’s a Python program that creates a list of words from the given
string which are less than size 8:

# Input string
input_string = "Python programming language has lot of applications in data
analytics"

# Split the input string into words

words = input_string.split()

# Filter words less than size 8

filtered_words = [word for word in words if len(word) < 8]

# Print the filtered words

print("Words less than size 8:")
print(filtered_words)

Output:

Words less than size 8:

['Python', 'has', 'lot', 'of', 'in', 'data']

2. Explain the concept of modules and packages with suitable example.

Certainly! Let’s explore the concepts of modules and packages in Python:

1. Modules:
o A module is a single file containing Python code.
o It allows you to organize your code into reusable units.
o Modules can define functions, classes, and variables.
o You can import modules to use their functionality in other Python
files.
o Example:
  Suppose you have a file named math_operations.py with the
following content:
 # math_operations.py
 def add(a, b):
 return a + b

 def subtract(a, b):
 return a - b
 You can use this module in another file:
 # main.py
 import math_operations

 result = math_operations.add(10, 5)
 print(f"Result of addition: {result}")
2. Packages:
o A package is a collection of related Python modules organized in
directories.
o It allows you to create a hierarchical structure for your code.
o Packages contain an __init__.py file (which can be empty) to indicate
that the directory is a package.
o Example:
 Suppose you have the following directory structure:
 my_project/
 my_package/
 __init__.py
 math_operations.py
 main.py
 Contents of math_operations.py:
 # math_operations.py
 def multiply(a, b):
 return a * b
 Contents of main.py:
 # main.py
 from my_package import math_operations

 result = math_operations.multiply(10, 5)
 print(f"Result of multiplication: {result}")
 3. Benefits:
o Modularity: Modules and packages allow you to break down large
applications into smaller, manageable units.
o Reusability: You can reuse modules and packages across different
projects.
o Namespace Management: Modules and packages provide separate
namespaces, avoiding naming conflicts.

3. Explain generators with example.

Certainly! In Python, generators are a powerful way to create iterators. They

allow you to produce a sequence of values lazily (one at a time) without storing all
of them in memory simultaneously. Generators are especially useful when dealing
with large data sets or infinite sequences. Let’s dive into generators with
examples:

1. Generator Functions:
o A generator function is defined like a normal function but uses the
yield keyword instead of return.
o When a generator function is called, it doesn’t execute the entire
function body immediately. Instead, it returns a generator object
that can be iterated over.
o The yield statement produces a value from the generator and pauses
the function’s execution until the next value is requested.
o Example of a simple generator function:
o def my_generator(n):
o value = 0
o while value < n:
o yield value
o value += 1
o
o # Iterate over the generator object produced by my_generator
o for val in my_generator(3):
o print(val)

Output:
 0
1
2

2. Generator Expressions:
o A generator expression is a concise way to create a generator object.
o It is similar to a list comprehension but creates an iterator instead of
a list.
o Example of creating a generator expression:
o # Create a generator object that produces squares of numbers from 0
to 4
o squares_generator = (i * i for i in range(5))
o
o # Iterate over the generator and print the values
o for square in squares_generator:
o print(square)

Output:

0
1
4
9
16

3. Benefits of Generators:
o Memory Efficiency: Generators produce values on-the-fly, so they
don’t store the entire sequence in memory.
o Lazy Evaluation: Values are generated only when needed, improving
performance.
o Infinite Sequences: Generators can represent infinite sequences
(e.g., Fibonacci numbers).

4. Write a program to swap two numbers without using temporary variable

accept input from the user
Certainly! Below is a Python program that swaps two numbers without using a
temporary variable. It accepts input from the user:

# Accept input from the user

num1 = float(input("Enter the first number: "))
num2 = float(input("Enter the second number: "))

# Swap the values without using a temporary variable

num1, num2 = num2, num1

# Print the swapped values

print(f"Swapped values: First number = {num1}, Second number = {num2}")

Feel free to input any two numbers, and the program will swap their values for

you! 😊

5. What is thread? Write a program that creates two threads. One thread
should print even numbers from 2 to 8 and the other should be print odd
numbers from 1 to 7.

Certainly! Let’s explore threads and create a Python program that demonstrates
multithreading.

1. Threads:
o A thread is the smallest unit of execution within a process.
o Threads share the same memory space and resources of the process
they belong to.
o Multithreading allows concurrent execution of multiple threads,
improving performance and responsiveness.
2. Python Program with Two Threads:
o We’ll create two threads: one for printing even numbers and another
for printing odd numbers.

import threading

def print_even_numbers():
 for i in range(2, 9, 2):
print(f"Even: {i}")

def print_odd_numbers():
for i in range(1, 8, 2):
print(f"Odd: {i}")

# Create two threads

even_thread = threading.Thread(target=print_even_numbers)
odd_thread = threading.Thread(target=print_odd_numbers)

# Start the threads

even_thread.start()
odd_thread.start()

# Wait for both threads to finish

even_thread.join()
odd_thread.join()

print("Both threads have finished.")

3. Explanation:
o We define two functions (print_even_numbers and
print_odd_numbers) that print even and odd numbers, respectively.
o We create two threads (even_thread and odd_thread) and assign the
corresponding functions as their targets.
o The start() method launches the threads.
o The join() method ensures that the main program waits for both
threads to finish before proceeding.
4. Output:
5. Even: 2
6. Even: 4
7. Even: 6
8. Even: 8
9. Odd: 1
10.Odd: 3
11.Odd: 5
12.Odd: 7
 13.Both threads have finished.

Feel free to adjust the program or explore more complex multithreading

scenarios! 😊

6. Write a program to accept an integer number and use try/except to catch

the exception if a floating point number is entered.

Certainly! Below is a Python program that accepts an integer number and uses
try/except to catch the exception if a floating point number is entered:

try:
# Accept an input from the user
num = int(input("Enter an integer number: "))
print(f"You entered: {num}")
except ValueError:
print("Invalid input! Please enter an integer number.")

In this program:

 We use a try block to attempt to convert the user input to an integer.

 If the input cannot be converted (e.g., if the user enters a floating point
number or a non-numeric value), a ValueError exception is raised.
 The except block catches the exception and prints an error message.

Feel free to input any value, and the program will handle it accordingly! 😊

7. What is thread synchronization? Explain with suitable example

Certainly! Thread synchronization is a crucial concept in multithreading. It

ensures that multiple threads coordinate their execution to avoid conflicts and
maintain data consistency. Let’s delve into thread synchronization with a suitable
example:
 1. Why Thread Synchronization?
o In a multithreaded environment, multiple threads can access shared
resources (e.g., variables, files, databases) concurrently.
o Without proper synchronization, race conditions, data corruption,
and unpredictable behavior can occur.
2. Types of Thread Synchronization:
o Mutual Exclusion (Mutex):
 Ensures that only one thread can access a critical section
(shared resource) at a time.
 Achieved using locks or semaphores.
o Cooperation (Inter-thread Communication):
 Threads communicate and coordinate their actions.
 Achieved using mechanisms like condition variables or
monitors.
3. Example: Mutual Exclusion (Mutex):
o Suppose we have two threads: ThreadA and ThreadB.
o They both need to increment a shared counter.
o Without synchronization, they might interfere with each other.
o We’ll use a mutex (lock) to ensure exclusive access to the counter.

import threading

# Shared counter
counter = 0

# Mutex (lock)
mutex = threading.Lock()

def increment_counter():
global counter
for _ in range(100000):
with mutex:
counter += 1

# Create two threads

threadA = threading.Thread(target=increment_counter)
threadB = threading.Thread(target=increment_counter)
# Start the threads
threadA.start()
threadB.start()

# Wait for both threads to finish

threadA.join()
threadB.join()

print(f"Final counter value: {counter}")

4. Explanation:
o We create a shared counter (counter) and a mutex (mutex).
o Both threads (ThreadA and ThreadB) increment the counter 100,000
times.
o The with mutex block ensures that only one thread can access the
counter at a time.
o The final counter value should be 200,000.
5. Output:
6. Final counter value: 200000

Thread synchronization ensures that the counter is updated correctly without

race conditions.

8. Write a program that reads a text file and count the number of lines and
words in the file.

Certainly! Below is a Python program that reads a text file, counts the number of
lines, and calculates the total number of words in the file:

def count_lines_and_words(filename):
try:
with open(filename, 'r') as file:
lines = file.readlines()
num_lines = len(lines)
num_words = sum(len(line.split()) for line in lines)
return num_lines, num_words
except FileNotFoundError:
 return None

# Example usage
filename = 'sample.txt' # Replace with your actual file name
result = count_lines_and_words(filename)
if result:
num_lines, num_words = result
print(f"Number of lines: {num_lines}")
print(f"Number of words: {num_words}")
else:
print(f"File '{filename}' not found.")

9. Write a program to validate strong password using regular expression

specify rules for the strong password.

Certainly! To validate a strong password using regular expressions, you can follow
these common rules:

1. Length: The password should be at least 8 characters long.

2. Uppercase Letters: It must contain at least 2 uppercase letters.
3. Lowercase Letters: It should have at least 3 lowercase letters.
4. Digits: There must be at least 2 digits (0-9).
5. Special Characters: Include at least one special character (e.g., !, @, #, $, &,
*).

Here’s a regular expression that satisfies these criteria:

^(?=.*[A-Z].*[A-Z])(?=.*[!@#$&*])(?=.*[0-9].*[0-9])(?=.*[a-z].*[a-z].*[a-z]).{8}$

Explanation:

 ^: Start anchor
 (?=.*[A-Z].*[A-Z]): Ensure the string has two uppercase letters.
 (?=.*[!@#$&*]): Ensure the string has at least one special character.
 (?=.*[0-9].*[0-9]): Ensure the string has two digits.
 (?=.*[a-z].*[a-z].*[a-z]): Ensure the string has three lowercase letters.
  .{8}: Ensure the string is of length 8.
 $: End anchor.

Feel free to adapt this regex to your specific requirements! 😊

If you’re using Python, here’s an example of how you can validate a password
using this regex:

import re

def is_strong_password(password):
regex = r"^(?=.*[A-Z].*[A-Z])(?=.*[!@#$&*])(?=.*[0-9].*[0-9])(?=.*[a-z].*[a-
z].*[a-z]).{8}$"
return bool(re.match(regex, password))

# Example usage:
password = "My$tr0ngP@ssw0rd"
if is_strong_password(password):
print("Valid strong password!")
else:
print("Not a strong password.")

Remember to adjust the regex or rules as needed for your specific use case! 🚀

For more information, you can refer to the following resources:

 Stack Overflow: Regex to validate password strength

 GeeksforGeeks: How to validate a Password using Regular Expressions in
Java
 Baeldung: Regular Expression for Password Validation in Java123

10.Create a class "Bank" having attributes "Bank name" "Branch", "City",

"Manager Name" and methods" "Change manager name" and "Display
 details." Wirte a constructor to initialize the instance variables. Write a
main program to demonstrate the use of Bank class.

Certainly! Let’s create a Python class called Bank with the specified attributes and
methods. We’ll also write a main program to demonstrate its usage.

class Bank:
def __init__(self, bank_name, branch, city, manager_name):
"""
Initializes the instance variables for the Bank class.

Args:
bank_name (str): The name of the bank.
branch (str): The branch name.
city (str): The city where the branch is located.
manager_name (str): The name of the branch manager.
"""
self.bank_name = bank_name
self.branch = branch
self.city = city
self.manager_name = manager_name

def change_manager_name(self, new_manager_name):

"""
Changes the branch manager's name.

Args:
new_manager_name (str): The new name of the branch manager.
"""
self.manager_name = new_manager_name

def display_details(self):
"""
Displays the bank details.
"""
print(f"Bank Name: {self.bank_name}")
print(f"Branch: {self.branch}")
 print(f"City: {self.city}")
print(f"Manager Name: {self.manager_name}")

# Example usage
if __name__ == "__main__":
bank1 = Bank(bank_name="ABC Bank", branch="Main Street", city="New York",
manager_name="John Doe")
bank1.display_details()

# Change manager name

bank1.change_manager_name("Jane Smith")
print("\nAfter changing manager name:")
bank1.display_details()

In this example, we create an instance of the Bank class, set its attributes, and
demonstrate how to change the manager’s name and display the bank details.
Feel free to modify the attributes and methods as needed for your specific use

case1. 😊

11.Write a program to find the occurrence and position of the substrings

within a string consider user input.

Certainly! Let’s create a Python program that finds the occurrence and position of
substrings within a given string. We’ll take user input for both the main string and
the substring. Here’s an example program:

def find_substring_occurrences(main_string, substring):

occurrences = []
index = 0
while index < len(main_string):
index = main_string.find(substring, index)
if index == -1:
break
occurrences.append(index)
index += len(substring)
 return occurrences

def main():
main_string = input("Enter the main string: ")
substring = input("Enter the substring to search for: ")

positions = find_substring_occurrences(main_string, substring)

if positions:
print(f"The substring '{substring}' occurs at positions: {positions}")
else:
print(f"The substring '{substring}' was not found in the main string.")

if __name__ == "__main__":
main()

In this program:

 We define a function find_substring_occurrences that iterates through the

main string using str.find().
 It keeps searching for the substring and appends the starting position of
each occurrence to a list.
 The main() function takes user input for the main string and the substring,
then calls the find_substring_occurrences function.
 If the substring is found, it prints the positions; otherwise, it informs the
user that the substring was not found.

Feel free to customize the input prompts and modify the program as needed! 😊

12.Write a program to demonstrate the overriding of the base class method

in the derived class.
Certainly! In Python, method overriding allows a child class to provide a specific
implementation of a method that is already provided by one of its parent classes.
When a method in a subclass has the same name, parameters, and return type as
a method in its super-class, it is said to override the method in the super-class 1.
Here’s an example demonstrating method overriding:

class Parent:
def show(self):
print("Inside Parent")

class Child(Parent):
def show(self):
print("Inside Child")

obj1 = Parent()
obj2 = Child()

obj1.show() # Output: Inside Parent

obj2.show() # Output: Inside Child

In this example, the Child class overrides the show method inherited from the
Parent class. When we create an object of Child, calling show() invokes the
overridden method in the child class1. Feel free to modify and experiment with

this code to explore method overriding further! 😊🐍

13.Write a program using mango DB database to create a "employee".

Collection having fields Emp ID, Name, Designation, Mobile, Department.
Accept the input from the user to insert the documents.

Certainly! Let’s create a MongoDB collection for employees with the specified
fields: Emp ID, Name, Designation, Mobile, and Department. I’ll provide you with
a Python example to achieve this.
First, make sure you have MongoDB installed and running. Then follow these
steps:

1. Install the MongoDB Python driver (pymongo) if you haven’t already. You
can do this using pip:
2. pip install pymongo

3. Write a Python script to create the collection and insert documents. Here’s
a sample script:
4. import pymongo
5.
6. # Connect to MongoDB (adjust the connection details as needed)
7. client = pymongo.MongoClient("mongodb://localhost:27017/")
8. db = client["mydatabase"] # Replace "mydatabase" with your desired
database name
9. collection = db["employees"]
10.
11.# Accept input from the user
12.emp_id = input("Enter Emp ID: ")
13.name = input("Enter Name: ")
14.designation = input("Enter Designation: ")
15.mobile = input("Enter Mobile: ")
16.department = input("Enter Department: ")
17.
18.# Create a document
19.employee_doc = {
20. "Emp ID": emp_id,
21. "Name": name,
22. "Designation": designation,
23. "Mobile": mobile,
24. "Department": department
25.}
26.
27.# Insert the document into the collection
28.collection.insert_one(employee_doc)
29.
30.print("Employee document inserted successfully!")
31.
 32.# Close the MongoDB connection
33.client.close()

34.Run the script and input the required details when prompted. The script
will insert the employee document into the “employees” collection.

Remember to replace the connection details (e.g., hostname, port, database

name) with your actual MongoDB setup. Additionally, consider error handling and
validation for user inputs in a production environment.

If you need further assistance or have any questions, feel free to ask! 😊

I’ve provided a Python example for creating the MongoDB collection and inserting
documents. If you have any specific requirements or need additional help, feel
free to ask! 12

14.What is string slice? How it is useful.

String slicing in Python allows you to obtain a sub-string from a given string by
selecting a portion of it. Let’s explore how string slicing works and its usefulness.

1. Using the slice() method:

o The slice() constructor creates a slice object representing a range of
indices specified by start, stop, and step.
o Syntax:
 slice(stop)
 slice(start, stop, step)
o Parameters:
 start: Starting index where the slicing begins.
 stop: Ending index where the slicing stops.
 step: Optional argument that determines the increment
between each index for slicing.
o Example:
 Python

# String slicing
my_string = 'ASTRING'
s1 = slice(3)
s2 = slice(1, 5, 2)
s3 = slice(-1, -12, -2)
print("String slicing")
print(my_string[s1]) # Output: AST
print(my_string[s2]) # Output: SR
print(my_string[s3]) # Output: GITA

AI-generated code. Review and use carefully. More info on FAQ.

2. Using list/array slicing ([::]) method:

o In Python, indexing syntax can be used as a substitute for the slice
object.
o This method is convenient for slicing strings using both list slicing and
array slicing.
o Syntax:
 arr[start:stop] (items from start through stop-1)
 arr[start:] (items from start through the rest of the array)
 arr[:stop] (items from the beginning through stop-1)
 arr[:] (a copy of the whole array)
 arr[start:stop:step] (start through not past stop, by step)
o Examples:
 Slicing from index 0 to 2 (stops at 3-1=2):

Python

my_string = 'GEEKSFORGEEKS'
print(my_string[:3]) # Output: GEE

AI-generated code. Review and use carefully. More info on

FAQ.

 Slicing from index 1 to 5 (stops at 3-1=2) with a step of 2:

 Python

my_string = 'GEEKSFORGEEKS'
print(my_string[1:5:2]) # Output: EK

AI-generated code. Review and use carefully. More info on

FAQ.

 Slicing from index -1 to -12 (stops at 3-1=2) with a step of -2:

Python

my_string = 'GEEKSFORGEEKS'
print(my_string[-1:-12:-2]) # Output: SEGOSE

AI-generated code. Review and use carefully. More info on

FAQ.

String slicing is useful for extracting specific portions of a string, such as substrings
or individual characters, which can be helpful for tasks like data manipulation,

text processing, and more12345. 😊

15.Explain deep copy with suitable example.

Certainly! In Python, deep copy and shallow copy are techniques used to
duplicate objects. Let me explain each of them with examples:

1. Shallow Copy:
o A shallow copy creates a new object that shares references to the
original object’s elements. It copies the top-level structure but not
the nested elements.
o When you modify a shallow copy, the original object may also be
affected.
o You can create a shallow copy using the copy.copy() function.
o Here’s an example using a list:
 2. import copy
3.
4. original_list = [1, 2, [3, 5], 4]
5. shallow_copy = copy.copy(original_list)
6.
7. # Modify the nested list in the shallow copy
8. shallow_copy[2][0] = 7
9.
10.print("Original list:", original_list) # [1, 2, [7, 5], 4]
11.print("Shallow copy:", shallow_copy) # [1, 2, [7, 5], 4]

As you can see, the nested list [3, 5] is shared between the original list and
the shallow copy.

12.Deep Copy:
o A deep copy creates a completely independent copy of the original
object, including all nested elements.
o Changes made to a deep copy do not affect the original object.
o You can create a deep copy using the copy.deepcopy() function.
o Here’s an example:
13.import copy
14.
15.original_list = [1, 2, [3, 5], 4]
16.deep_copy = copy.deepcopy(original_list)
17.
18.# Modify the nested list in the deep copy
19.deep_copy[2][0] = 9
20.
21.print("Original list:", original_list) # [1, 2, [3, 5], 4]
22.print("Deep copy:", deep_copy) # [1, 2, [9, 5], 4]

The deep copy creates a separate copy of the nested list, so changes to the
deep copy do not affect the original list.

In summary:

 Shallow copy shares references to nested elements.

 Deep copy creates an independent copy of all elements, recursively.
Feel free to ask if you have any more questions! 😊

16.Write a program using monogo DB database to create a collection "Chess

competition" with helds (Player id, player_name, player_age,
player_phone) and display all registrations.

Certainly! To create a MongoDB collection named “Chess competition” with the

specified fields and display all registrations, you can follow these steps using
Python and the pymongo library:

1. Install pymongo: First, make sure you have the pymongo library installed. If
not, you can install it using pip:
2. pip install pymongo

3. Write the Python code: Below is an example Python script that creates the
collection and inserts some sample data. You’ll need to replace the sample
data with actual player information.
4. import pymongo
5.
6. # Connect to MongoDB (assuming it's running locally)
7. client = pymongo.MongoClient("mongodb://localhost:27017/")
8. db = client["mydatabase"] # Replace "mydatabase" with your desired
database name
9.
10.# Create the "Chess competition" collection
11.collection_name = "Chess competition"
12.chess_collection = db[collection_name]
13.
14.# Sample player data (replace with actual data)
15.players = [
16. {
17. "player_id": 1,
18. "player_name": "Alice",
19. "player_age": 25,
 20. "player_phone": "123-456-7890",
21. },
22. {
23. "player_id": 2,
24. "player_name": "Bob",
25. "player_age": 30,
26. "player_phone": "987-654-3210",
27. },
28. # Add more players as needed
29.]
30.
31.# Insert sample data into the collection
32.chess_collection.insert_many(players)
33.
34.# Display all registrations
35.for player in chess_collection.find():
36. print(f"Player ID: {player['player_id']}")
37. print(f"Name: {player['player_name']}")
38. print(f"Age: {player['player_age']}")
39. print(f"Phone: {player['player_phone']}")
40. print("-" * 20)
41.
42.# Close the MongoDB connection
43.client.close()

44.Run the script: Save the above code to a Python file (e.g.,
chess_competition.py) and execute it. It will create the collection, insert the
sample data, and display the registrations.

Remember to adjust the database connection details (e.g., hostname, port,

authentication) according to your MongoDB setup. Additionally, replace the
sample player data with actual information for your chess competition

participants. 😊
For more information on MongoDB collections and the createCollection() method,
you can refer to the official MongoDB documentation1. If you have any further

questions, feel free to ask! 🌟

17.Create pandas dataframe using 2D list and perform following operations.

i) Display first 5 rows.
ii) Count missing values in column 2nd

Certainly! Let’s create a Pandas DataFrame from a two-dimensional list and then
perform the requested operations.

Here’s how you can create a DataFrame from a 2D list and display the first 5 rows:

import pandas as pd

# Example 2D list
lst = [['Geek', 25], ['is', 30], ['for', 26], ['Geeksforgeeks', 22]]

# Create a DataFrame with specified column names

df = pd.DataFrame(lst, columns=['Tag', 'number'])

# Display the first 5 rows

print(df.head(5))

The output will be:

Tag number
0 Geek 25
1 is 30
2 for 26
3 Geeksforgeeks 22

Now, let’s count the missing values in the second column (‘number’):

missing_values_count = df['number'].isnull().sum()
print(f"Number of missing values in column 'number': {missing_values_count}")

Feel free to adjust the 2D list and column names according to your specific data! 😊

If you have any more questions or need further assistance, feel free to ask! 🚀

18.Create 3x3 numpy array and determine median and mode.

Certainly! Let’s break this down into two steps:

1. Creating a 3x3 Numpy Array: To create a 3x3 Numpy array, we can use the
numpy library. Here’s an example code snippet:
2. import numpy as np
3.
4. # Create a 3x3 numpy array with all elements as 0
5. arr = np.zeros((3, 3))

The resulting array arr will be a 3x3 matrix filled with zeros1.

6. Determining the Median and Mode: Let’s assume we have some data in
our 3x3 array. For demonstration purposes, I’ll use the following data:
7. [[1, 2, 3],
8. [4, 5, 6],
9. [7, 8, 9]]

o Median: The median is the middle value when the data is sorted.
Since our data is already sorted, the median is the value in the
center. In this case, the median is 5.
o Mode: The mode is the most frequently occurring value. To find the
mode, we can use the scipy.stats.mode() function. Let’s calculate it:
o from scipy import stats
o
o data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
o mode_result = stats.mode(data)
 o
o # The mode value(s)
o mode_values = mode_result.mode
o print("Mode:", mode_values)

The output will be the mode value(s) from the data2.

Remember to replace the example data with your actual values when working
with your specific array. If you have any further questions or need additional

assistance, feel free to ask! 😊

19.Create dataframe using three series having size 10, series are account
number, name and balance.

Certainly! Let’s create a Pandas DataFrame using three series: account number,
name, and balance. I’ll provide two examples—one where each series represents
a column, and another where each series represents a row.

Example 1: Creating a DataFrame with Series as Columns Suppose we have the

following three pandas Series:

import pandas as pd

# Define three Series

account_number = pd.Series([101, 102, 103, 104, 105])
name = pd.Series(['Alice', 'Bob', 'Charlie', 'David', 'Eve'])
balance = pd.Series([5000, 8000, 6500, 7200, 9500])

We can convert each series into a DataFrame and then concatenate them all into
one DataFrame:

# Convert each Series to a DataFrame

account_df = account_number.to_frame(name='account_number')
name_df = name.to_frame(name='name')
balance_df = balance.to_frame(name='balance')
# Concatenate the three Series into one DataFrame
df = pd.concat([account_df, name_df, balance_df], axis=1)

# View the final DataFrame

print(df)

The resulting DataFrame will look like this:

account_number name balance

0 101 Alice 5000
1 102 Bob 8000
2 103 Charlie 6500
3 104 David 7200
4 105 Eve 9500

Example 2: Creating a DataFrame with Series as Rows Suppose we have the

following three pandas Series:

# Define three Series

row1 = pd.Series([101, 'Alice', 5000])
row2 = pd.Series([102, 'Bob', 8000])
row3 = pd.Series([103, 'Charlie', 6500])

We can combine each of the Series into a pandas DataFrame, using each Series as
a row in the DataFrame:

# Create DataFrame using Series as rows

df = pd.DataFrame([row1, row2, row3])

# Create column names for DataFrame

df.columns = ['account_number', 'name', 'balance']

# View the resulting DataFrame

print(df)

The resulting DataFrame will look like this:

account_number name balance

0 101 Alice 5000
1 102 Bob 8000
2 103 Charlie 6500

Feel free to adapt these examples to your specific data! 😊123

20. Draw pie chart using matplotlib and decorate it by adding various
elements use suitable data.

Certainly! Let’s create a pie chart using Matplotlib in Python. We’ll start with a
simple example and then customize it by adding various elements.

import matplotlib.pyplot as plt

import numpy as np

# Example data
cars = ['AUDI', 'BMW', 'FORD', 'TESLA', 'JAGUAR', 'MERCEDES']
data = [23, 17, 35, 29, 12, 41]

# Create a pie chart

fig = plt.figure(figsize=(10, 7))
plt.pie(data, labels=cars)

# Display the chart

plt.show()

This basic pie chart shows the distribution of car brands. Now let’s enhance it by
adding more elements:

1. Start Angle: We can rotate the chart by a specified angle in a counter-

clockwise direction. This is useful for emphasizing a particular segment.
2. Explode: We can separate a portion of the chart by specifying an “explode”
parameter. This creates a gap between the wedges.
3. Colors: We can define custom colors for each wedge.
 4. Autopct: We can display the percentage values on the wedges.
5. Legend and Title: Adding a legend and a title improves readability and
aesthetics.

Here’s an example with additional customization:

# Customized pie chart

explode = (0.1, 0.0, 0.2, 0.3, 0.0, 0.0)
colors = ["orange", "cyan", "brown", "grey", "indigo", "beige"]

def func(pct, allvalues):

absolute = int(pct / 100. * np.sum(allvalues))
return f"{pct:.1f}%\n({absolute} cars)"

fig, ax = plt.subplots(figsize=(10, 7))

wedges, texts, autotexts = ax.pie(data, autopct=lambda pct: func(pct, data),
explode=explode, colors=colors, wedgeprops={'linewidth': 1,
'edgecolor': 'green'})

# Add legend and title

ax.legend(wedges, cars, title="Car Brands", loc="center left", bbox_to_anchor=(1,
0, 0.5, 1))
plt.title("Distribution of Car Brands")

# Display the customized chart

plt.show()

Feel free to adjust the parameters and explore different styles for your pie chart!

📊🚗123
 SAMPLE QUESTIONS

Explain the Features of python programming

Certainly! Python is a dynamic, high-level, free open source, and interpreted programming
language with several distinctive features:

1. Free and Open Source: Python is freely available on the official website. Being open-
source, its source code is accessible to the public, allowing users to download, use, and
share it.
2. Easy to Code: Python’s high-level nature makes it easy to learn and write code.
Compared to languages like C, C#, Java, or JavaScript, Python is developer-friendly, and
beginners can grasp its basics within hours or days.
 3. Easy to Read: Python’s syntax is straightforward. Code blocks are defined by
indentation rather than semicolons or brackets, enhancing readability.
4. Object-Oriented Language: Python supports object-oriented programming, including
concepts like classes and object encapsulation.
5. GUI Programming Support: Modules like PyQt5, PyQt4, wxPython, or Tk enable
graphical user interface (GUI) development in Python. PyQt5 is a popular choice for
creating graphical apps.
6. High-Level Language: Python abstracts system architecture and memory management,
making it developer-friendly.
7. Large Community Support: Python has gained popularity, and platforms like
StackOverflow provide answers to numerous Python-related questions.
8. Easy to Debug: Python’s error traces facilitate quick identification and correction of
program issues.
9. Portability: Python is portable across platforms (e.g., Windows, Linux, Unix, Mac)
without code modification.
10. Integrated Language: Python integrates seamlessly with other languages like C, C++,
etc.
11. Interpreted Language: Python interprets code line by line, allowing rapid development
and easy debugging12345.

explain the Modules in Python programming

Certainly! In Python, modules play a crucial role in organizing and managing code. Let’s dive
into the details:

1. What is a Module?
o A module in Python is essentially a single file containing Python code. It can
include:
 Functions
 Classes
 Variables
 Executable statements
o Modules act as self-contained units of code that can be imported and used in
other programs or modules.
2. Creating a Module:
o Suppose we want to create a simple module named example.py. We can define a
function inside it, like this:
o # example.py
o def add(a, b):
o result = a + b
o return result
o In this example, the add()
function takes two numbers and returns their sum.
3. Importing Modules:
o We use the import keyword to bring the definitions from a module into another
module or the interactive Python interpreter.
 o For instance, to import our example module, we do:
o import example
o We can then access the add() function using the dot (.) operator:
o result = example.add(4, 5) # Returns 9
4. Standard Library Modules:
o Python comes with a rich set of standard modules (over 200 of them). These
modules cover various functionalities.
o For example, to get the value of π (pi), we can use the math module:
o import math
o print("The value of pi is", math.pi) # Output: 3.141592653589793
5. Renaming Modules:
o We can also import a module by renaming it. For instance:
o import math as m
o print(m.pi) # Output: 3.141592653589793
6. Importing Specific Names:
o Sometimes, we only need specific attributes from a module. We can do this using
the from ... import statement:
o from math import pi
o print(pi) # Output: 3.141592653589793
7. Importing Everything (Not Recommended):
o While it’s possible to import all names from a module using from ... import
*, it’s not a good practice:
o from math import *
o print("The value of pi is", pi)
o Avoid this approach to prevent potential naming conflicts.

Remember, modules help organize code, reduce complexity, and enhance reusability in Python

programs! 🐍🔗

For more details, you can explore the Python standard modules and their use cases1.

explain the Mutable & immutable in python

In Python, objects can be categorized into two main types: mutable and immutable. Let’s delve
into what these terms mean:

1. Immutable Objects:
o Immutable objects cannot be changed after they are created.
o Once instantiated, their values remain fixed throughout their lifetime.
o Examples of immutable objects include:
 Integers: Numeric values like 42 or -10.
 Floats: Decimal numbers such as 3.14.
 Strings: Textual data like "hello" or "world".
 Tuples: Ordered collections of elements enclosed in parentheses, e.g., (1,
2, 3).
 o Attempting to modify an immutable object results in an error. For instance:
 If we try to change an element in a tuple:
 tuple1 = (0, 1, 2, 3)
 tuple1[0] = 4 # Throws a TypeError: 'tuple' object does not
support item assignment
 Similarly, modifying a character in a string:
 message = "Welcome to GeeksforGeeks"
 message[0] = 'p' # Throws a TypeError: 'str' object does
not support item assignment
2. Mutable Objects:
o Mutable objects can be modified after creation.
o Their internal state can change without creating a new instance.
o Examples of mutable objects include:
 Lists: Dynamic collections of items enclosed in square brackets, e.g., [1,
2, 3].
 Dictionaries: Key-value pairs represented as {key: value}.
 Sets: Unordered collections of unique elements.
o Lists, for instance, allow adding or removing elements dynamically:
o my_list = [1, 2, 3]
o my_list.append(4)
o my_list.insert(1, 5)
o my_list.remove(2)
o popped_element = my_list.pop(0)
o # Output: [1, 2, 3, 4], [1, 5, 2, 3, 4], [1, 5, 3, 4], [5, 3, 4]

In summary, immutable objects retain their original values, while mutable objects allow
modifications. Understanding this distinction is crucial for effective Python programming12345.

Explain break, continue and pass of Python

Certainly! Let’s delve into the details of break, continue, and pass statements in Python:

1. Break Statement:
o The break statement is used to terminate a loop (either a for loop or a while
loop) prematurely.
o When the break statement is encountered within a loop, the control immediately
exits the loop, and execution continues with the statements following the loop.
o If the break statement is nested within multiple loops, it only terminates the
innermost loop containing the break.
o Here’s the syntax for the break statement:
o for item in iterable:
o # some code
o if condition:
o break
o # more code
o Example:
o s = 'geeksforgeeks'
 o for letter in s:
o print(letter)
o if letter == 'e' or letter == 's':
o break
o print("Out of for loop")
o
o i = 0
o while True:
o print(s[i])
o if s[i] == 'e' or s[i] == 's':
o break
o i += 1
o print("Out of while loop")

Output:

g
e
Out of for loop
g
e
Out of while loop

2. Continue Statement:
o The continue statement is used to skip the current iteration of a loop and
proceed to the next iteration.
o Unlike break, it doesn’t exit the loop entirely; instead, it jumps to the next
iteration.
o When the continue statement is encountered, the code following it within the
loop is skipped.
o Here’s the syntax for the continue statement:
o for item in iterable:
o # some code
o if condition:
o continue
o # more code
o Example:
o for i in range(1, 5):
o for j in range(2, 6):
o if j % i == 0:
o break
o print(i, j)

Output:

3 2
4 2
4 3

3. Pass Statement:
o The pass statement is a no-op (no operation) statement.
 o It serves as a placeholder when you need syntactically correct code but don’t want
any specific action to be taken.
o It’s often used in empty function definitions, class definitions, or conditional
blocks where you plan to implement something later.
o Here’s an example:
o def my_function():
o pass # Placeholder for future implementation
o
o if some_condition:
o pass # Placeholder for handling a specific case
o The pass statement ensures that Python doesn’t raise an error due to an empty
block.

Remember, these control statements provide flexibility and allow you to tailor your loops to

specific requirements! 😊

For more detailed information, you can refer to the GeeksforGeeks article on this topic1.

Explain lambda function in python

In Python, a lambda function is a small, anonymous function defined using the lambda
keyword. It can take any number of arguments but only has one expression, which is evaluated
and returned. Here’s the basic syntax:

lambda arguments: expression

Here are a few examples of lambda functions in action:

 Adding 10 to an argument and returning the result:

x = lambda a: a + 10
print(x(5)) # Output: 15

 Multiplying two arguments and returning the result:

x = lambda a, b: a * b
print(x(5, 6)) # Output: 30

 Summing three arguments and returning the result:

x = lambda a, b, c: a + b + c
print(x(5, 6, 2)) # Output: 13

Lambda functions are particularly useful when you need a simple function for a short period and
are commonly used as arguments to higher-order functions (functions that take other functions as
arguments). They are also used when you need to pass a simple function as an argument to
another function12.

Explain conditional statements in Python

Conditional statements in Python are used to execute a block of code only if a certain condition
is met. They are a fundamental part of programming, allowing for decision-making and control
flow within a program. Conditional statements in Python are used to execute a block of code
only if a certain condition is met. They are the backbone of decision-making in programming.
Here’s a brief overview with examples:

1. If Statement: The if statement is the most basic form of conditional statement. It executes
the code block only if the condition evaluates to True.

# Example of if statement
age = 20
if age >= 18:
print("You are eligible to vote.")

2. If-else Statement: The if-else statement provides an alternative path of execution when the
if condition is False.

# Example of if-else statement

age = 16
if age >= 18:
print("You are eligible to vote.")
else:
print("You are not eligible to vote yet.")

3. Elif Statement: The elif (short for else if) statement allows for multiple conditions to be
checked in sequence.

# Example of elif statement

age = 65
if age < 18:
print("You are a minor.")
elif age < 65:
print("You are an adult.")
else:
print("You are a senior citizen.")

4. Nested If Statement: A nested if is an if statement inside another if statement. It’s used for
checking multiple conditions.

# Example of nested if statement

num = 9
if num >= 0:
if num == 0:
 print("Zero")
else:
print("Positive number")
else:
print("Negative number")

5. Ternary Operator: Python also supports a shorthand way of writing conditional statements
known as the ternary operator.

# Example of ternary operator

age = 20
status = "Eligible" if age >= 18 else "Not Eligible"
print(status)

These examples should give you a good understanding of how conditional statements work in
Python. Remember, the key is that the code block under a conditional statement will only
execute if the condition is True.

Explain how to access Strings, also various methods associated with it

In Python, strings are sequences of characters and can be accessed using indexing and slicing.
Here’s a brief overview with examples:

Accessing Strings:

 Indexing: You can access individual characters in a string using an index inside square
brackets. Python uses zero-based indexing.

# Accessing characters in a string

s = "Hello, World!"
print(s[1]) # 'e'

 Slicing: You can access a range of characters in a string using the slicing operator : with
start and end indices.

# Slicing a string
s = "Hello, World!"
print(s[1:5]) # 'ello'

String Methods: Python provides a variety of string methods that perform different operations
on strings. Here are some commonly used methods with examples:

 .upper(): Converts all characters in the string to uppercase.

s = "hello"
print(s.upper()) # 'HELLO'
  .lower(): Converts all characters in the string to lowercase.

s = "HELLO"
print(s.lower()) # 'hello'

 .find(): Searches the string for a specified value and returns the position of where it
was found.

s = "Hello"
print(s.find('e')) # 1

 .replace(): Returns a string where a specified value is replaced with a specified value.

s = "Hello, World!"
print(s.replace('World', 'Python')) # 'Hello, Python!'

 .split(): Splits the string at the specified separator and returns a list.

s = "Hello, World!"
print(s.split(',')) # ['Hello', ' World!']

These are just a few examples of how to access and manipulate strings in Python. There are
many more methods available, each with its own functionality. Remember that string methods do
not change the original string but return a new string with the applied changes.

What do you mean by function? Explain function and it’s type with suitable
example

In Python programming, a function is a block of code that performs a specific task. It is defined
using the def keyword, and it can accept parameters and return a value. Functions help to break
down complex problems into smaller, manageable pieces, making the code more organized,
reusable, and easier to read.

There are two main types of functions in Python:

1. Built-in Functions: These are pre-defined functions that are always available in Python.
You don’t need to define these functions; you can simply call them. Examples include
print(), len(), and range().
2. User-Defined Functions: These are functions that you create yourself to perform
specific tasks. You can define them using the def keyword followed by the function
name and parentheses which may include parameters.

Here’s an example of a user-defined function that adds two numbers:

# Function definition
def add_numbers(num1, num2):
 sum = num1 + num2
return sum

# Function call
result = add_numbers(5, 3)
print("The sum is:", result)

In this example, add_numbers is the function name, num1 and num2 are parameters, and sum is
the variable that holds the result of adding num1 and num2. The return statement is used to send
the result back to the caller.

Functions can also be more complex, accepting multiple parameters, returning multiple values,
and performing various tasks within their body. They are a fundamental part of Python and a
powerful tool for any programmer.

What is dictionary? Explain with suitable example

In Python, a dictionary is a collection of key-value pairs, where each key is associated with a
value. The keys in a dictionary are unique and immutable (which means they cannot be
changed), while the values can be of any data type and can be duplicated and changed.

Here’s an example to illustrate how to create and use a dictionary in Python:

# Creating a dictionary
person = {
"name": "Alice",
"age": 25,
"city": "New York"
}

# Accessing dictionary values

print(person["name"]) # Output: Alice
print(person["age"]) # Output: 25

# Adding a new key-value pair

person["email"] = "alice@example.com"

# Updating an existing value

person["age"] = 26

# Removing a key-value pair

del person["city"]

# Printing the updated dictionary

print(person)

In this example:
  We created a dictionary named person with keys “name”, “age”, and “city”, and
associated values.
 We accessed the values using their keys.
 We added a new key-value pair for “email”.
 We updated the value for the key “age”.
 We removed the key-value pair for “city”.
 Finally, we printed the updated dictionary, which would output: {'name': 'Alice',
'age': 26, 'email': 'alice@example.com'}.

Dictionaries are versatile and can be used for various tasks like storing data records, counting
items, or even as a simple database.

Write a program to open a textfile ‘emp1’ and ‘emp2’ and store all the information of
both the files in ‘ emprecord’ file

Certainly! Here’s a Python program that opens the text files ‘emp1’ and ‘emp2’, and stores all
their contents into a new file called ‘emprecord’:

# Open 'emp1' and 'emp2' in read mode and 'emprecord' in write mode
with open('emp1', 'r') as emp1, open('emp2', 'r') as emp2, open('emprecord',
'w') as emprecord:
# Read the content of 'emp1' and write to 'emprecord'
emprecord.write(emp1.read())
# Ensure separation between the contents of the two files
emprecord.write("\\n")
# Read the content of 'emp2' and write to 'emprecord'
emprecord.write(emp2.read())

# Print a success message

print("The information from 'emp1' and 'emp2' has been successfully stored in
'emprecord'.")

When you run this code, it will combine the contents of ‘emp1’ and ‘emp2’ into ‘emprecord’.
Please make sure that the files ‘emp1’ and ‘emp2’ exist in the same directory as your script, or
provide the correct path to them.

If you encounter any issues or have further questions, feel free to ask!

Write a program to validate date pattern using regexp (2022-05-11)

Certainly! Here’s a Python program that uses a regular expression to validate the date pattern:

import re

# Define a function to validate date pattern using regex

def validate_date(date):
# Define the regex pattern for the date
pattern = r'^\\d{4}-\\d{2}-\\d{2}$'

# Use regex to match the pattern

if re.match(pattern, date):
return True
else:
return False

# Test the function with the provided date

date_to_validate = "2022-05-11"
is_valid = validate_date(date_to_validate)

# Print the result

print(f"The date {date_to_validate} is {'valid' if is_valid else 'invalid'}.")

When I ran this code with the date “2022-05-11”, the output confirmed that the date is valid. If
you have any other dates you’d like to validate or need further assistance, feel free to ask!

Write a program to create a derived class current_ account from Account class derived
class consist two method deposit and withdraw display the deposit and withdraw
amount

Certainly! Here’s a Python program that creates a derived class CurrentAccount from a base
class Account. The derived class includes two methods: deposit and withdraw, which allow
you to deposit or withdraw funds from the account. Additionally, it displays the deposit and
withdraw amounts.

# Assuming the Account class is already defined

class Account:
def __init__(self, account_number, account_holder, balance=0):
self.account_number = account_number
self.account_holder = account_holder
self.balance = balance

# Derived class CurrentAccount from Account class

class CurrentAccount(Account):
def deposit(self, amount):
self.balance += amount
print(f"Deposited: {amount}. New Balance: {self.balance}")

def withdraw(self, amount):

if amount > self.balance:
print("Insufficient funds!")
else:
self.balance -= amount
print(f"Withdrawn: {amount}. New Balance: {self.balance}")

# Example usage:
# Create a CurrentAccount object
current_acc = CurrentAccount("123456789", "John Doe")

# Deposit and withdraw amounts

current_acc.deposit(1000)
current_acc.withdraw(500)

# Display the deposit and withdraw amount

print(f"Deposit amount: 1000")
print(f"Withdraw amount: 500")

When you run this program, it will create an instance of CurrentAccount, deposit 1000 units
into the account, withdraw 500 units, and then display the transactions. The output will be:

Deposited: 1000. New Balance: 1000

Withdrawn: 500. New Balance: 500
Deposit amount: 1000
Withdraw amount: 500

Feel free to modify the account number and account holder’s name as needed for your use case.
If you need further assistance or modifications, let me know!

Write a program to perform basic CRUD operations with MongoDB

Certainly! Below is a Python program that demonstrates basic CRUD (Create, Read, Update,
Delete) operations using MongoDB. Please ensure you have pymongo installed and a running
MongoDB instance to execute this code.

from pymongo import MongoClient

# Connect to the MongoDB client

client = MongoClient('localhost', 27017)

# Select the database

db = client['test_database']

# Select the collection

collection = db['test_collection']

# CREATE operation: Insert a document into the collection

document = {"name": "John", "age": 30, "city": "New York"}
insert_result = collection.insert_one(document)
print(f"Inserted document id: {insert_result.inserted_id}")

# READ operation: Query the collection

query_result = collection.find_one({"name": "John"})
print(f"Found document: {query_result}")

# UPDATE operation: Update a document in the collection

update_result = collection.update_one({"name": "John"}, {"$set": {"age": 31}})
print(f"Updated document count: {update_result.modified_count}")
# DELETE operation: Delete a document from the collection
delete_result = collection.delete_one({"name": "John"})
print(f"Deleted document count: {delete_result.deleted_count}")

# Close the connection

client.close()

This script connects to a MongoDB instance running on localhost with the default port 27017.
It performs the following operations:

 Creates a new document in the test_collection of the test_database.

 Reads the inserted document by querying for a document with the name “John”.
 Updates the age of the document where the name is “John”.
 Deletes the document where the name is “John”.

Remember to replace 'localhost', 27017, 'test_database', and 'test_collection' with

your actual MongoDB connection details and desired database and collection names.

If you encounter any issues or need further assistance, feel free to ask!

series in pandas python

Certainly! In Python, a Pandas Series is a one-dimensional labeled data structure that can hold
various types of data, including integers, strings, floats, and other Python objects. It’s a
fundamental building block in the Pandas library for data manipulation and analysis.

Here are some key points about Pandas Series:

1. Creation of a Series:
o You can create a Pandas Series using the constructor pandas.Series().
o It can be initialized from various data sources, such as lists, NumPy arrays,
dictionaries, and scalar values.
o For example, to create a simple Series from an array, you can use:
o import pandas as pd
o import numpy as np
o
o data = np.array(['g', 'e', 'e', 'k', 's'])
o ser = pd.Series(data)
o print(ser)

Output:

0 g
1 e
2 e
3 k
4 s
 dtype: object

2. Indexing and Accessing Elements:

o A Series has an associated index (similar to row labels in an Excel sheet).
o You can access elements by their position (using integer-based indexing) or by
their label (using index labels).
o For example, to retrieve the first five elements of a Series:
o data = np.array(['g', 'e', 'e', 'k', 's', 'f', 'o', 'r', 'g', 'e',
'e', 'k', 's'])
o ser = pd.Series(data)
o print(ser[:5])

Output:

0 g
1 e
2 e
3 k
4 s
dtype: object

3. Use Cases:
o Pandas Series are commonly used for:
 Storing columnar data (similar to a column in an Excel sheet).
 Performing operations involving the index (such as filtering, aggregation,
and transformation).

Remember that the axis labels in a Pandas Series are collectively called the index, and while
labels need not be unique, they must be hashable types12345. If you have any specific questions or

need further examples, feel free to ask! 😊

Visualization Tools
Python offers a variety of libraries for data visualization, each with its own set of features and
capabilities. Here’s a brief overview of some popular Python visualization tools:

 Matplotlib: A comprehensive library for creating static, animated, and interactive

visualizations. It’s known for its ability to produce publication-quality plots and its
flexibility in customizing visual styles and layouts1.
 Seaborn: Built on top of Matplotlib, Seaborn provides a high-level interface for drawing
attractive and informative statistical graphics. It simplifies the creation of complex plots2.
 Plotly: An interactive graphing library that allows you to create sophisticated plots and
dashboards in your web browser or Jupyter notebook.
 Bokeh: Designed for modern web browsers, Bokeh is great for creating interactive plots
and dashboards that can be embedded in web applications.
  Pygal: A Python library that creates SVG (Scalable Vector Graphics) plots, which are
particularly useful for creating charts that need to be scalable and interactive.
 Dash: A framework for building analytical web applications. It’s particularly suited for
creating complex interactive dashboards.
 Altair: A declarative statistical visualization library in Python. Altair’s API is simple,
friendly, and consistent and built on a solid foundation of the Vega and Vega-Lite
visualization grammars.

These tools can help you visualize your data in Python, whether you’re looking to create simple
charts or complex interactive visualizations. Each tool has its own strengths, so the best choice
depends on the specific needs of your project.

Universal Array Function

In Python, a universal function, or ufunc, refers to a function that operates on ndarray objects
from NumPy on an element-by-element basis. These functions are a core part of NumPy, a
library for numerical computing in Python. Ufuncs are designed to be fast and are used to
perform operations like addition, multiplication, and trigonometric functions across arrays
efficiently.

Here’s a simple example of how a ufunc works with NumPy arrays:

import numpy as np

# Define two arrays

array1 = np.array([1, 2, 3, 4])
array2 = np.array([5, 6, 7, 8])

# Use a ufunc to perform element-wise addition

result = np.add(array1, array2)

print(result) # Output: [ 6 8 10 12]

In this example, np.add is a ufunc that takes two arrays and performs element-wise addition.
There are many other ufuncs available in NumPy for different operations, including
trigonometric functions, logical operations, and more12.

If you’re looking to create your own ufunc, NumPy provides a way to do this using the
frompyfunc method, which allows you to turn a regular Python function into a ufunc that can
operate on NumPy arrays1.