1.
Program to check whether a year is leap year or not
def is_leap_year(year):
if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
return True
else:
return False
# Example usage:
year_to_check = 2024 # Replace this with the year you want to check
if is_leap_year(year_to_check):
print(f"{year_to_check} is a leap year.")
else:
print(f"{year_to_check} is not a leap year.")
2. Program to check duplicate character in a given string
def has_duplicate_characters(input_string):
char_count = {}
for char in input_string:
# Check if the character is already in the dictionary
if char in char_count:
return True # Duplicate character found
else:
char_count[char] = 1
return False # No duplicate characters found
# Example usage:
input_str = "hello" # Replace this with the string you want to check
if has_duplicate_characters(input_str):
print(f"The string '{input_str}' has duplicate characters.")
else:
print(f"The string '{input_str}' does not have duplicate characters.")
3. Program demonstrate various string functions and
operations
# Define a sample string
sample_string = "Hello, World! How are you doing?"
# Basic string operations
print("Original String:", sample_string)
print("Length of String:", len(sample_string))
print("Concatenation:", sample_string + " I'm fine, thank you!")
print("Repetition:", sample_string * 2)
print("Substring:", sample_string[7:12]) # Extracting substring
print("Uppercase:", sample_string.upper())
print("Lowercase:", sample_string.lower())
print("Replace 'World' with 'Universe':", sample_string.replace("World", "Universe"))
# String formatting
name = "Alice"
age = 30
formatted_string = f"Hello, {name}! You are {age} years old."
print("Formatted String:", formatted_string)
# String splitting and joining
word_list = sample_string.split() # Split the string into a list of words
print("Split String:", word_list)
joined_string = "-".join(word_list) # Join the words using a hyphen
print("Joined String:", joined_string)
# Checking for substring existence
substring = "How"
if substring in sample_string:
print(f"'{substring}' found in the string.")
else:
print(f"'{substring}' not found in the string.")
# Stripping whitespace
whitespace_string = " Some spaces "
print("Original String:", whitespace_string)
print("Stripped String:", whitespace_string.strip())
# String formatting using the format() method
formatted_string_2 = "My name is {} and I'm {} years old.".format("Bob", 25)
print("Formatted String (using format()):", formatted_string_2)
4. Program to demonstrate list function and operatins
# Creating a sample list
sample_list = [1, 2, 3, 4, 5]
# Basic list operations
print("Original List:", sample_list)
print("Length of List:", len(sample_list))
print("Concatenation:", sample_list + [6, 7, 8])
print("Repetition:", sample_list * 2)
print("Accessing Elements:")
print("First Element:", sample_list[0])
print("Slicing:", sample_list[1:4]) # Extracting a sublist
sample_list[2] = 99 # Modifying an element
print("Modified List:", sample_list)
# List methods
sample_list.append(6) # Appending an element
print("Appended List:", sample_list)
removed_element = sample_list.pop() # Removing and returning the last element
print("Popped Element:", removed_element)
print("List after Pop:", sample_list)
sample_list.extend([7, 8, 9]) # Extending the list with another list
print("Extended List:", sample_list)
sample_list.remove(99) # Removing a specific element
print("List after Removal:", sample_list)
index_of_4 = sample_list.index(4) # Finding the index of an element
print("Index of 4:", index_of_4)
sample_list.insert(2, 100) # Inserting an element at a specific index
print("List after Insertion:", sample_list)
sample_list.reverse() # Reversing the list in place
print("Reversed List:", sample_list)
sorted_list = sorted(sample_list) # Creating a new sorted list
print("Sorted List (new):", sorted_list)
# List comprehension
squared_numbers = [x ** 2 for x in sample_list]
print("Squared Numbers:", squared_numbers)
# Checking for element existence
if 3 in sample_list:
print("3 is present in the list.")
else:
print("3 is not present in the list.")
# Clearing the list
sample_list.clear()
print("Cleared List:", sample_list)
5. Program to demonstrate tuple function and operation
# Creating a sample tuple
sample_tuple = (1, 2, 3, 4, 5)
# Basic tuple operations
print("Original Tuple:", sample_tuple)
print("Length of Tuple:", len(sample_tuple))
print("Concatenation:", sample_tuple + (6, 7, 8))
print("Repetition:", sample_tuple * 2)
print("Accessing Elements:")
print("First Element:", sample_tuple[0])
print("Slicing:", sample_tuple[1:4]) # Extracting a subtuple
# Tuple methods
index_of_3 = sample_tuple.index(3) # Finding the index of an element
print("Index of 3:", index_of_3)
# Tuple comprehension (generating a new tuple based on existing tuple)
squared_numbers = tuple(x ** 2 for x in sample_tuple)
print("Squared Numbers:", squared_numbers)
# Checking for element existence
if 3 in sample_tuple:
print("3 is present in the tuple.")
else:
print("3 is not present in the tuple.")
# Unpacking a tuple
a, b, *rest = sample_tuple
print("Unpacked Values:")
print("a:", a)
print("b:", b)
print("Rest:", rest)
# Nested tuple
nested_tuple = ((1, 2), (3, 4), (5, 6))
print("Nested Tuple:", nested_tuple)
# Converting a tuple to a list and vice versa
tuple_to_list = list(sample_tuple)
print("Tuple converted to List:", tuple_to_list)
list_to_tuple = tuple(tuple_to_list)
print("List converted to Tuple:", list_to_tuple)
6. Program to demonstrate dictionary function and operation
# Creating a sample dictionary
sample_dict = {'name': 'John', 'age': 30, 'city': 'New York'}
# Basic dictionary operations
print("Original Dictionary:", sample_dict)
print("Length of Dictionary:", len(sample_dict))
print("Accessing Values:")
print("Name:", sample_dict['name'])
print("Age:", sample_dict['age'])
# Dictionary methods
sample_dict['occupation'] = 'Engineer' # Adding a new key-value pair
print("Dictionary after Addition:", sample_dict)
sample_dict['age'] = 31 # Modifying the value of an existing key
print("Dictionary after Modification:", sample_dict)
removed_value = sample_dict.pop('city') # Removing and returning a value by key
print("Removed City:", removed_value)
print("Dictionary after Removal:", sample_dict)
# Getting keys, values, and items
keys = sample_dict.keys()
values = sample_dict.values()
items = sample_dict.items()
print("Keys:", keys)
print("Values:", values)
print("Items:", items)
# Checking for key existence
if 'name' in sample_dict:
print("'name' is a key in the dictionary.")
else:
print("'name' is not a key in the dictionary.")
# Dictionary comprehension
squared_values = {key: value ** 2 for key, value in sample_dict.items()}
print("Squared Values:", squared_values)
# Clearing the dictionary
sample_dict.clear()
print("Cleared Dictionary:", sample_dict)
7. Program to find sum of a digit of number using recursion
def sum_of_digits(n):
# Base case: if the number has only one digit
if n < 10:
return n
else:
# Recursive case: sum the last digit and the sum of the remaining digits
return n % 10 + sum_of_digits(n // 10)
# Example usage:
number = 12345 # Replace this with the number for which you want to find the sum of digits
result = sum_of_digits(number)
print(f"The sum of digits in {number} is {result}.")
8. Program to print inverted star pattern
def inverted_star_pattern(rows):
for i in range(rows, 0, -1):
for j in range(0, rows - i):
print(" ", end="")
for k in range(0, i):
print("*", end="")
print()
# Example usage:
num_rows = 5 # Replace this with the number of rows you want in the pattern
inverted_star_pattern(num_rows)
9. Program to display fibonacci series using recursion
def fibonacci(n):
if n <= 0:
return "Please enter a positive integer."
elif n == 1:
return [0]
elif n == 2:
return [0, 1]
else:
fib_series = fibonacci(n - 1)
fib_series.append(fib_series[-1] + fib_series[-2])
return fib_series
# Example usage:
num_terms = 10 # Replace this with the number of terms you want in the Fibonacci series
result = fibonacci(num_terms)
print(f"Fibonacci Series with {num_terms} terms: {result}")
10. Program to demonstrate set operations
# Create two sample sets
set1 = {1, 2, 3, 4, 5}
set2 = {3, 4, 5, 6, 7}
# Basic set operations
print("Set 1:", set1)
print("Set 2:", set2)
# Union of sets
union_set = set1.union(set2)
print("Union of Set 1 and Set 2:", union_set)
# Intersection of sets
intersection_set = set1.intersection(set2)
print("Intersection of Set 1 and Set 2:", intersection_set)
# Difference between sets
difference_set1 = set1.difference(set2)
difference_set2 = set2.difference(set1)
print("Difference of Set 1 - Set 2:", difference_set1)
print("Difference of Set 2 - Set 1:", difference_set2)
# Symmetric difference between sets
symmetric_difference_set = set1.symmetric_difference(set2)
print("Symmetric Difference of Set 1 and Set 2:", symmetric_difference_set)
# Checking for subset and superset
is_subset = set1.issubset(set2)
is_superset = set1.issuperset(set2)
print("Is Set 1 a subset of Set 2?", is_subset)
print("Is Set 1 a superset of Set 2?", is_superset)
# Adding and removing elements from a set
set1.add(6)
set2.remove(6)
print("Set 1 after adding element 6:", set1)
print("Set 2 after removing element 6:", set2)
# Clearing a set
set1.clear()
print("Cleared Set 1:", set1)
11. Program to find quotient and reminder of two numbers
def find_quotient_and_remainder(dividend, divisor):
quotient = dividend // divisor
remainder = dividend % divisor
return quotient, remainder
# Example usage:
dividend = int(input("Enter the dividend: "))
divisor = int(input("Enter the divisor: "))
# Ensure that the divisor is not zero to avoid division by zero error
if divisor != 0:
result_quotient, result_remainder = find_quotient_and_remainder(dividend, divisor)
print(f"The quotient of {dividend} divided by {divisor} is {result_quotient}")
print(f"The remainder of {dividend} divided by {divisor} is {result_remainder}")
else:
print("Error: Division by zero is not allowed.")
12. find area and parameter of a circle using class
import math
class Circle:
def __init__(self, radius):
self.radius = radius
def calculate_area(self):
area = math.pi * self.radius ** 2
return area
def calculate_perimeter(self):
perimeter = 2 * math.pi * self.radius
return perimeter
# Example usage:
radius = float(input("Enter the radius of the circle: "))
# Ensure that the radius is non-negative
if radius >= 0:
# Create an instance of the Circle class
circle_instance = Circle(radius)
# Calculate and display the area and perimeter
area = circle_instance.calculate_area()
perimeter = circle_instance.calculate_perimeter()
print(f"The area of the circle with radius {radius} is: {area:.2f}")
print(f"The perimeter of the circle with radius {radius} is: {perimeter:.2f}")
else:
print("Error: Please enter a non-negative radius.")
13. program to remove duplicate from a list
def remove_duplicates(input_list):
unique_list = list(set(input_list))
return unique_list
# Example usage:
input_list = [1, 2, 2, 3, 4, 4, 5, 6, 6, 7]
result_list = remove_duplicates(input_list)
print("Original List:", input_list)
print("List after removing duplicates:", result_list)
14. Program to demonstrate inheritance and method
overriding
class Animal:
def __init__(self, name):
self.name = name
def make_sound(self):
print(f"{self.name} makes a generic animal sound.")
class Dog(Animal):
def __init__(self, name, breed):
# Call the constructor of the superclass (Animal)
super().__init__(name)
self.breed = breed
def make_sound(self):
print(f"{self.name} barks loudly.")
class Cat(Animal):
def __init__(self, name, color):
# Call the constructor of the superclass (Animal)
super().__init__(name)
self.color = color
def make_sound(self):
print(f"{self.name} meows softly.")
# Example usage:
dog_instance = Dog("Buddy", "Golden Retriever")
cat_instance = Cat("Whiskers", "Gray")
# Using the overridden method for each instance
dog_instance.make_sound()
cat_instance.make_sound()
15. Program to demonstrate multiple inheritance
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def display_info(self):
print(f"Name: {self.name}, Age: {self.age}")
class Employee:
def __init__(self, employee_id, salary):
self.employee_id = employee_id
self.salary = salary
def display_info(self):
print(f"Employee ID: {self.employee_id}, Salary: ${self.salary}")
class Manager(Person, Employee):
def __init__(self, name, age, employee_id, salary, department):
# Call constructors of both base classes
Person.__init__(self, name, age)
Employee.__init__(self, employee_id, salary)
# Additional attribute for Manager class
self.department = department
def display_info(self):
# Call display_info methods of both base classes
Person.display_info(self)
Employee.display_info(self)
print(f"Department: {self.department}")
# Example usage:
manager_instance = Manager("John", 35, "E123", 80000, "HR")
manager_instance.display_info()
