1.

Python program to calculate the area and perimeter (circumference) of

a circle:

import math

# Function to calculate area and perimeter of a circle

def circle_properties(radius):
area = math.pi * radius ** 2 # Formula for area: A = π * r^2
perimeter = 2 * math.pi * radius # Formula for perimeter (circumference): P = 2 * π * r
return area, perimeter

# Input the radius of the circle

radius = float(input("Enter the radius of the circle: "))

# Call the function and display the results

area, perimeter = circle_properties(radius)
print(f"Area of the circle: {area:.2f}")
print(f"Perimeter (Circumference) of the circle: {perimeter:.2f}")

Explanation:

1. The program uses the math.pi constant to get the value of π (pi).
2. It defines a function circle_properties() that calculates:
o Area using the formula A=πr2A = \pi r^2A=πr2
o Perimeter (Circumference) using the formula P=2πrP = 2 \pi rP=2πr
3. The user is prompted to input the radius, and the program prints the area and perimeter,
rounded to two decimal places.
 2. Python program to generate the Fibonacci series:

# Function to generate Fibonacci series up to 'n' terms

def fibonacci_series(n):
fib_sequence = []
a, b = 0, 1
for _ in range(n):
fib_sequence.append(a)
a, b = b, a + b
return fib_sequence

# Input number of terms in the Fibonacci series

n = int(input("Enter the number of terms in the Fibonacci series: "))

# Generate and display the Fibonacci series

fib_sequence = fibonacci_series(n)
print(f"Fibonacci series up to {n} terms: {fib_sequence}")

Explanation:

1. The function fibonacci_series(n) generates the Fibonacci sequence up to n terms.

o It starts with the first two terms a = 0 and b = 1.
o In each iteration of the loop, it appends the current value of a to the list, then
updates a and b for the next iteration.
2. The program prompts the user to input the number of terms (n) they want in the series.
3. It then prints the Fibonacci series up to the entered number of terms.

For example, if the user enters 7, the program will output:

Fibonacci series up to 7 terms: [0, 1, 1, 2, 3, 5, 8]

 3. Python program to calculate the Greatest Common Divisor (GCD) of two
numbers

# Function to calculate GCD using the Euclidean algorithm

def gcd(a, b):
while b:
a, b = b, a % b
return a

# Input two numbers

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

# Calculate and display the GCD

result = gcd(num1, num2)
print(f"The GCD of {num1} and {num2} is: {result}")
 4. Python program that generates the first N prime numbers:

# Function to check if a number is prime

def is_prime(num):
if num <= 1:
return False
for i in range(2, int(num ** 0.5) + 1):
if num % i == 0:
return False
return True

# Function to generate first N prime numbers

def generate_primes(n):
primes = []
num = 2 # Start checking from 2
while len(primes) < n:
if is_prime(num):
primes.append(num)
num += 1
return primes

# Input number of prime numbers to generate

n = int(input("Enter the number of prime numbers to generate: "))

# Generate and display the prime numbers

prime_numbers = generate_primes(n)
print(f"The first {n} prime numbers are: {prime_numbers}")

Explanation:

1. is_prime(num): This function checks if a number is prime by testing divisibility from 2

up to the square root of the number.
2. generate_primes(n): This function generates the first n prime numbers by checking each
number starting from 2. If the number is prime, it adds it to the list of primes.
3. The program asks the user to input the number of prime numbers they want to generate,
then displays the first n prime numbers.

Example:

If the user enters:

Enter the number of prime numbers to generate: 5

The output will be:

The first 5 prime numbers are: [2, 3, 5, 7,

 5. Python program that calculates the sum of the squares of the first N
natural numbers:

# Function to calculate the sum of squares of first N natural numbers

def sum_of_squares(n):
return sum(i ** 2 for i in range(1, n + 1))

# Input: Number of natural numbers

n = int(input("Enter a number N to calculate the sum of squares of first N natural
numbers: "))

# Calculate and display the sum of squares

result = sum_of_squares(n)
print(f"The sum of squares of the first {n} natural numbers is: {result}")

Explanation:

1. The function sum_of_squares(n) computes the sum of the squares of numbers from 1 to
n. It uses a generator expression inside the sum() function to compute the squares.
2. The user is prompted to input a number n which determines how many natural numbers
(starting from 1) to consider.
3. The program then calculates and prints the sum of their squares.

Example:

If the user inputs 5, the program will calculate:

1^2 + 2^2 + 3^2 + 4^2 + 5^2 = 1 + 4 + 9 + 16 + 25 = 55

Output:

The sum of squares of the first 5 natural numbers is: 55

 6. Python program to find the sum of the elements of an array (or list):

# Input array from the user

arr = list(map(int, input("Enter the elements of the array (space-separated): ").split()))

# Find the sum of the elements of the array

sum_of_elements = sum(arr)

# Display the sum

print(f"The sum of the elements in the array is: {sum_of_elements}")

Explanation:

1. Input: The program asks the user to input the elements of the array, separated by spaces.
These elements are converted into a list of integers using map() and split().
2. Sum of elements: The sum() function is used to calculate the sum of the elements in the
list.
3. Output: The program prints the sum of the elements in the array.

Example:

If the user inputs:

Enter the elements of the array (space-separated): 1 2 3 4 5

The output will be:

The sum of the elements in the array is: 15

This program calculates the sum of the elements in an array and displays it.
 7. Python program to find the largest element in an array:

# Function to find the largest element in the array

def find_largest(arr):
if len(arr) == 0:
return None # Return None if the array is empty
largest = arr[0] # Assume the first element is the largest
for num in arr:
if num > largest:
largest = num # Update largest if a larger element is found
return largest

# Input: Array of numbers

arr = list(map(int, input("Enter the elements of the array (space-separated): ").split()))

# Find and display the largest element

largest_element = find_largest(arr)
if largest_element is not None:
print(f"The largest element in the array is: {largest_element}")
else:
print("The array is empty.")

Explanation:

1. find_largest(arr): This function iterates through each element in the array and keeps
track of the largest number found. Initially, it assumes the first element to be the largest
and then compares it with each subsequent element.
2. User input: The program asks for the input of an array, where the user enters the
elements separated by spaces. The map and split functions are used to convert the input
into a list of integers.
3. It checks if the array is empty and handles that case by returning None.

Example:

If the user inputs:

Enter the elements of the array (space-separated): 3 9 1 7 4

 8. Python program to check if a string is a palindrome or not:

# Function to check if a string is palindrome

def is_palindrome(s):
# Remove spaces and convert to lowercase for case-insensitive comparison
s = s.replace(" ", "").lower()
return s == s[::-1]

# Input string
string = input("Enter a string to check if it's a palindrome: ")

# Check and display result

if is_palindrome(string):
print(f"'{string}' is a palindrome.")
else:
print(f"'{string}' is not a palindrome.")

Explanation:

1. is_palindrome(s):
o The function first removes spaces (s.replace(" ", "")) and converts the string to
lowercase (.lower()) to ensure case-insensitive and space-insensitive comparison.
o It then checks if the string is equal to its reverse (s[::-1]), which is a common
technique to reverse a string in Python.

2. User input: The program prompts the user to input a string.

3. Output: It prints whether the string is a palindrome or not based on the check.

Example:

If the user inputs:

Enter a string to check if it's a palindrome: madam

The output will be:

'madam' is a palindrome.

If the user inputs:

Enter a string to check if it's a palindrome: hello

The output will be:

'hello' is not a palindrome.

9. Python program that stores a string in a list and prints the elements of
the list:

# Input a string
string = input("Enter a string: ")

# Store the string in a list (each character will be an element)

string_list = list(string)

# Print the list

print("The string stored in the list is:")
print(string_list)

Explanation:

1. Input a string: The program asks the user to input a string.

2. Convert string to list: The list() function is used to convert the string into a list, where
each character becomes an individual element in the list.
3. Print the list: The program then prints the list.

Example:

If the user inputs:

Enter a string: hello

The output will be:

The string stored in the list is:

['h', 'e', 'l', 'l', 'o']

This program stores each character of the string as a separate element in the list and prints the
list.
 10.Python program that demonstrates how to find the length of a list,
reverse it, copy it, and clear it:

# Input list from the user

lst = list(map(int, input("Enter the elements of the list (space-separated): ").split()))

# 1. Find the length of the list

length = len(lst)
print(f"Length of the list: {length}")

# 2. Reverse the list

reversed_lst = lst[::-1]
print(f"Reversed list: {reversed_lst}")

# 3. Copy the list

copied_lst = lst.copy()
print(f"Copied list: {copied_lst}")

# 4. Clear the list

lst.clear()
print(f"List after clearing: {lst}")

Explanation:

1. Find the length: We use the len() function to find the number of elements in the list.
2. Reverse the list: We reverse the list using slicing (lst[::-1]), which returns a new list that
is the reverse of the original.
3. Copy the list: We use the copy() method to create a shallow copy of the list.
4. Clear the list: We use the clear() method to remove all elements from the list, leaving it
empty.

Example:

If the user inputs:

Enter the elements of the list (space-separated): 1 2 3 4 5

The output will be:

Length of the list: 5

Reversed list: [5, 4, 3, 2, 1]
Copied list: [1, 2, 3, 4, 5]
List after clearing: []