## Python Programs for Practice

Welcome to our section dedicated to the Python programming language. You will find a set of information related to this language (course support, code examples, …).

Here is a small examples of python programming language.

### How to Print “Hello World!” in Python

**Python 3 Code:**

1 2 3 4 5 |
# This program prints Hello, world! print('Hello, world!') |

This simple program uses the `print()`

function to output the string “Hello, world!” to the console. This is a common first program for people learning a new programming language, as it helps to ensure that the development environment is set up correctly and that the programmer knows how to write and run a program.

In python the `print()`

function is used for displaying output on the console.It takes one or more parameters, which are the values to be printed. Each parameter is separated by a comma. In this case, “Hello, world!” is passed as the only parameter to the print function.

In Python 3 , `print`

is a function, so it needs to be called with paranthesis. But in python 2 `print`

is not a function so it dont need paranthesis.

It’s also worth noting that the string “Hello, world!” is enclosed in quotation marks, which indicate that it is a string of characters. In Python, strings are enclosed in either single quotes (‘) or double quotes (“), and they can contain any combination of letters, numbers, and symbols.

When you run this program, the following will be output to the console:

1 2 3 |
Hello, world! |

This is the string “Hello, world!” that was passed as a parameter to the `print()`

function.

You can run this program by saving it in a file with a `.py`

extension and then running the file using the python interpreter. you can also do that by writing the code in the interpreter(running python in the command line) and it will directly give the output.

### How to Add Two Variables in Python

**Python 3 Code:**

1 2 3 4 5 6 7 8 9 |
# This program adds two numbers num1 = 5.5 num2 = 1.15 # Add two numbers sum = float(num1) + float(num2) # Display the sum print('The sum of {0} and {1} is {2}'.format(num1, num2, sum)) |

This program correctly adds two numbers, `num1`

and `num2`

, and then prints out the result. Here’s a breakdown of what each line of the code is doing:

`num1 = 5.5`

: This line assigns the value 5.5 to the variable `num1`

.

`num2 = 1.15`

: This line assigns the value 1.15 to the variable `num2`

.

`sum = float(num1) + float(num2)`

: This line takes the values of `num1`

and `num2`

, converts them to float and add them and assigns the result to the variable `sum`

.

`print('The sum of {0} and {1} is {2}'.format(num1, num2, sum))`

: This line uses the `print()`

function to output a string containing the sum of `num1`

and `num2`

. The `format()`

method is used to insert the values of `num1`

, `num2`

, and `sum`

into the string. The `{0}`

, `{1}`

, and `{2}`

are placeholders for the values of `num1`

, `num2`

, and `sum`

respectively, that will be formatted into the string.

This is a simple program that demonstrates the basic use of variables and the arithmetic operation in python. You can also perform arithmetic operation in the same way as in mathematical expressions.

For instance `sum = num1 + num2`

would also work and this line will also give the same result.

You will get the output as:

1 2 3 |
The sum of 5.5 and 1.15 is 6.65 |

### How to Find the Square Root in Python

**Python 3 Code:**

1 2 3 4 5 6 7 8 9 |
# Python Program to calculate the square root #to take the input from the user num = float(input('Enter a number: ')) num_sqrt = num ** 0.5 print('The square root of %0.3f is %0.3f'%(num ,num_sqrt)) |

This program correctly calculates the square root of a number entered by the user and prints out the result. Here’s a breakdown of what each line of the code is doing:

`num = float(input('Enter a number: '))`

: This line uses the `input()`

function to prompt the user to enter a number, which is then stored as a floating-point value in the variable `num`

.

`num_sqrt = num ** 0.5`

: This line calculates the square root of the number stored in `num`

. It uses the ** operator to raise the value of `num`

to the power of 0.5.

`print('The square root of %0.3f is %0.3f'%(num ,num_sqrt))`

: This line uses the `print()`

function to output a string containing the square root of the number entered by the user. The string contains placeholders for the values of `num`

and `num_sqrt`

which are formatted into the string using the `%`

operator. The `%0.3f`

is used to format the floating-point number, where 0.3 represents the width of the field and f represents the type of number (floating-point).

Note that the `math`

module also provides a function `sqrt()`

which can be used to calculate the square root of a number, this code snippet is a simple example of how you can use mathematical operations in python to calculate square root of a number

When you run the program, it will ask the user to enter a number, and then it will calculate and print the square root of that number rounded upto 3 decimal points.

When you run this program, the following output will be displayed on the console:

1 2 3 4 |
Enter a number: 9 The square root of 9.000 is 3.000 |

When the program is run, it will first prompt the user to enter a number. Once the user enters a number and press enter, the program will calculate the square root of the number, and then it will print out the result in the following format `The square root of 9.000 is 3.000`

, where `9.000`

is the input number and `3.000`

is the square root of that number rounded upto 3 decimal points.

As you can see the program is asking user to enter the number, and then it’s printing the square root of that number rounded upto 3 decimal points.

### How to Calculate the Area of a Triangle in Python

**Python 3 Code:**

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
# Python Program to find the area of triangle # to take inputs from the user a = float(input('Enter first side: ')) b = float(input('Enter second side: ')) c = float(input('Enter third side: ')) # calculate the semi-perimeter s = (a + b + c) / 2 # calculate the area area = (s*(s-a)*(s-b)*(s-c)) ** 0.5 print('The area of the triangle is %0.2f' %area) |

this program correctly calculates the area of a triangle given the lengths of its three sides, and prints out the result. Here’s a breakdown of what each line of the code is doing:

`a = float(input('Enter first side: '))`

, `b = float(input('Enter second side: '))`

, `c = float(input('Enter third side: '))`

: These lines use the `input()`

function to prompt the user to enter the three side lengths of the triangle (`a`

, `b`

, `c`

), which are then stored as floating-point values.

`s = (a + b + c) / 2`

: This line calculates the semi-perimeter of the triangle using the formula (a+b+c)/2, where a, b and c are the sides of the triangle.

`area = (s*(s-a)*(s-b)*(s-c)) ** 0.5`

: This line calculates the area of the triangle using Heron’s formula. Heron’s formula is a formula that can be used to find the area of a triangle when you know the lengths of all three sides. It states that the area of a triangle is equal to the square root of s(s-a)(s-b)(s-c), where s is the semi-perimeter and a,b and c are the sides of the triangle.

`print('The area of the triangle is %0.2f' %area)`

: This line uses the `print()`

function to output a string containing the area of the triangle. The `%0.2f`

is used to format the floating-point number, where 0.2 represents the width of the field and f represents the type of number (floating-point).

When you run this program, it will first prompt the user to enter the three side lengths of the triangle (`a`

, `b`

, `c`

), once the user enter the values for the sides the program will calculate the area of the triangle and will produce the following output:

1 2 3 4 5 6 |
Enter first side: 3 Enter second side: 4 Enter third side: 5 The area of the triangle is 6.00 |

Where `3`

, `4`

and `5`

are the sides entered by the user and `6.00`

is the area of the triangle rounded upto 2 decimal points. This output is calculated using Heron’s formula and assuming that the sides provided form a valid triangle.

### How to Calculate the Area of a Circle in Python

**Python Code:**

1 2 3 4 5 6 7 8 9 10 11 |
# Python program to find Area of a circle def findArea(r): PI = 3.142 return PI * (r*r) # Driver method num=float(input("Enter r value:")) print("Area is %.6f" % findArea(num)) |

This program correctly calculates the area of a circle, given the radius and prints out the result. Here’s a breakdown of what each line of the code is doing:

`def findArea(r):`

: This line defines a function named `findArea`

, which takes a single parameter `r`

, which represents the radius of the circle.

`PI = 3.142`

: This line assigns a value of 3.142 to the constant `PI`

.

`return PI * (r*r)`

: This line calculates the area of a circle with the given radius and returns the value to the calling function. It uses the formula for the area of a circle, which is PI * r^2. Where PI is a mathematical constant and r is the radius of the circle.

`num=float(input("Enter r value:"))`

: This line prompts the user to enter the value of the radius of the circle and

stores the input as a floating point value in the variable `num`

using `input()`

function.

`print("Area is %.6f" % findArea(num))`

: This line calls the`findArea()`

function with the value of`num`

as the argument, calculates the area of the circle, and stores the result in a variable. The`print()`

statement is then used to print the area rounded upto 6 decimal points by using the string formatting`%.6f`

.

When you run the program, it will prompt the user to enter the value of the radius of the circle, then it will calculate and print the area of the circle rounded upto 6 decimal points.

Example output:

1 2 3 4 |
Enter r value:5 Area is 78.539816 |

Here, user enters 5 as the radius of the circle and the program calculates the area of the circle with radius 5, and prints the area rounded upto 6 decimal points which is 78.539816.

### How to Solve Quadratic Equation in Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
# Solve the quadratic equation ax**2 + bx + c = 0 # import complex math module import cmath # To take coefficient input from the users a = float(input('Enter a: ')) b = float(input('Enter b: ')) c = float(input('Enter c: ')) # calculate the discriminant d = (b**2) - (4*a*c) # find two solutions sol1 = (-b-cmath.sqrt(d))/(2*a) sol2 = (-b+cmath.sqrt(d))/(2*a) print('The solution are {0} and {1}'.format(sol1,sol2)) |

This program correctly solves the quadratic equation ax^2 + bx + c = 0, given the values of the coefficients a, b and c, and prints out the solutions. Here’s a breakdown of what each line of the code is doing:

`import cmath`

: This line imports the `cmath`

module, which provides support for complex number arithmetic.

`a = float(input('Enter a: '))`

, `b = float(input('Enter b: '))`

, `c = float(input('Enter c: '))`

: These lines use the `input()`

function to prompt the user to enter the values of the coefficients (a, b, and c) which are then stored as floating-point values.

`d = (b**2) - (4*a*c)`

: This line calculates the discriminant using the formula b^2 – 4ac, where b, a and c are the coefficients of the equation.

`sol1 = (-b-cmath.sqrt(d))/(2*a)`

, `sol2 = (-b+cmath.sqrt(d))/(2*a)`

: These lines use the quadratic formula to calculate the two solutions for the equation. The quadratic formula is (-b+-√(b^2-4ac))/2a. The `cmath.sqrt()`

is used to get the square root of the discriminant. Using the cmath.sqrt instead of the math.sqrt returns complex numbers if the discriminant is negative.

`print('The solution are {0} and {1}'.format(sol1,sol2))`

: This line uses the `print()`

function to output the two solutions of the quadratic equation which are stored in variables sol1 and sol2.

The program takes 3 coefficients as input and it will return the two roots of the quadratic equation. It is important to note that, when the discriminant is negative, the solutions will be complex numbers, which will be represented in the form of `a + bj`

, where a and b are real numbers, and j represents the square root of -1.

### How to Swap Two Variables in Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
# Python program to swap two variables # To take input from the user x = input('Enter value of x: ') y = input('Enter value of y: ') # create a temporary variable and swap the values temp = x x = y y = temp print('The value of x after swapping: {}'.format(x)) print('The value of y after swapping: {}'.format(y)) |

This program correctly swaps the values of two variables, `x`

and `y`

, and then prints out the new values of the variables. Here’s a breakdown of what each line of the code is doing:

`x = input('Enter value of x: ')`

and `y = input('Enter value of y: ')`

: These lines use the `input()`

function to prompt the user to enter the values of x and y, which are then stored as strings.

`temp = x`

: This line assigns the value of x to a temporary variable `temp`

.

`x = y`

and `y = temp`

: These lines swap the values of x and y by assigning the value of y to x and the value of the temporary variable to y.

`print('The value of x after swapping: {}'.format(x))`

and `print('The value of y after swapping: {}'.format(y))`

: These lines use the `print()`

function to output the new values of the variables x and y after the swap. The `.format()`

method is used to insert the values of `x`

and `y`

into the string.

This program uses a temporary variable to swap the values of x and y. This is the most common way to swap values of two variables. This method is not limited to swapping integers or floats, but also it can be used with string, or any other datatype.

When you run this program, it will prompt the user to enter the values of x and y, and then it will swap the values of the two variables and produce the following output:

1 2 3 4 5 6 |
Enter value of x: 5 Enter value of y: 10 The value of x after swapping: 10 The value of y after swapping: 5 |

Here, user entered 5 for x and 10 for y, the program swaps the value of x and y, so now the value of x is 10 and the value of y is 5. These values will be displayed as the output of the program.

### How to Generate a Random Number in Python

1 2 3 4 5 6 7 8 |
# Program to generate a random number between 0 and 100 # import the random module import random print(random.randint(0,100)) |

This program generates a random integer between 0 and 100 (inclusive) and prints it out. Here’s a breakdown of what each line of the code is doing:

`import random`

: This line imports the `random`

module, which provides a suite of functions for generating random numbers.

`print(random.randint(0,100))`

: This line generates a random integer between 0 and 100 (inclusive) using the `random.randint()`

function, and then it uses the `print()`

function to output the result. `random.randint(0,100)`

will return a random integer between 0 and 100.

Keep in mind that the numbers generated by this function are determined by a starting seed, which you can set with `random.seed()`

if you want to obtain the same sequence of random numbers again.

The output of this program will be a single random integer between 0 and 100 (inclusive) each time the program is executed. For example, some possible outputs could be:

1 2 3 |
55 |

1 2 3 |
99 |

### How to Convert Kilometers to Miles in Python

1 2 3 4 5 6 7 8 9 10 11 12 13 |
kilometers = 10 # To take kilometers from the user kilometers = float(input("Enter value in kilometers")) # conversion factor conv_fac = 0.621371 # calculate miles miles = kilometers * conv_fac print('%0.3f kilometers is equal to %0.3f miles' %(kilometers,miles)) |

Yes, this program correctly converts a distance given in kilometers to miles, and prints out the result. Here’s a breakdown of what each line of the code is doing:

`kilometers = float(input("Enter value in kilometers"))`

: This line prompts the user to enter a distance in kilometers, which is then stored as a floating-point value in the variable `kilometers`

using the `input()`

function.

`conv_fac = 0.621371`

: This line assigns a value of 0.621371 to the variable `conv_fac`

, which represents the conversion factor from kilometers to miles.

`miles = kilometers * conv_fac`

: This line calculates the equivalent distance in miles by multiplying the distance in kilometers by the conversion factor.

`print('%0.3f kilometers is equal to %0.3f miles' %(kilometers,miles))`

: This line uses the `print()`

function to output a string containing the original distance in kilometers and the equivalent distance in miles. The `%0.3f`

is used to format the floating-point numbers, where 0.3 represents the width of the field and f represents the type of number (floating-point).

When you run this program, it will prompt the user to enter a distance in kilometers, and then it will convert it to miles using the conversion factor and produce the following output:

1 2 3 4 |
Enter value in kilometers: 10 10.000 kilometers is equal to 6.213 miles |

Here, user entered 10 for the distance in kilometers, the program converts the kilometers to miles using the conversion factor and displays the output rounded upto 3 decimal places. Keep in mind that the output will be different each time depending on the value entered by user.

### How to Convert Celsius To Fahrenheit in Python

1 2 3 4 5 6 7 8 9 10 |
# Python Program to convert temperature in celsius to fahrenheit # To take celsius from the user celsius= float(input("Enter value in celsius")) # calculate fahrenheit fahrenheit = (celsius * 1.8) + 32 print('%0.1f degree Celsius is equal to %0.1f degree Fahrenheit' %(celsius,fahrenheit)) |

this program correctly converts a temperature given in celsius to fahrenheit, and prints out the result. Here’s a breakdown of what each line of the code is doing:

`celsius= float(input("Enter value in celsius"))`

: This line prompts the user to enter a temperature in celsius, which is then stored as a floating-point value in the variable `celsius`

using the `input()`

function.

`fahrenheit = (celsius * 1.8) + 32`

: This line calculates the equivalent temperature in fahrenheit by using the formula (C * 1.8) + 32, where C is the temperature in celsius.

`print('%0.1f degree Celsius is equal to %0.1f degree Fahrenheit' %(celsius,fahrenheit))`

: This line uses the `print()`

function to output a string containing the original temperature in celsius and the equivalent temperature in fahrenheit. The `%0.1f`

is used to format the floating-point numbers, where 0.1 represents the width of the field and f represents the type of number (floating-point).

The program prompts the user to enter the temperature in celsius, and then it converts it to fahrenheit using the conversion factor and displays the output rounded upto 1 decimal place.

When you run this program, it will prompt the user to enter a temperature in celsius, and then it will convert it to fahrenheit using the conversion formula and produce the following output:

1 2 3 4 |
Enter value in celsius: 20 20.0 degree Celsius is equal to 68.0 degree Fahrenheit |

Here, user entered 20 for the temperature in celsius, the program converts the celsius to fahrenheit using the conversion formula and displays the output rounded upto 1 decimal places. Keep in mind that the output will be different each time depending on the value entered by user.

### How to Find the Sum of Numbers in a List in Python

**Example Code:**

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
# Python 3 code to find sum # of elements in given array def _sum(arr,n): # return sum using sum # inbuilt sum() function return(sum(arr)) # driver function arr=[] # input values to list arr = [120, 30, 24, 5] # calculating length of array n = len(arr) ans = _sum(arr,n) # display sum print ('Sum of the array is ',ans) |

** **This program is a simple implementation of a function in Python that calculates the sum of elements in a given array.

The program defines a function called `_sum()`

that takes in two arguments, an array `arr`

and an integer `n`

. The function uses the built-in `sum()`

function in Python to find the sum of all the elements in the array `arr`

.

The driver function creates an empty array called `arr`

and then assigns a list of integers to it (120, 30, 24, 5). The program then calculates the length of the array using the `len()`

function and assigns it to the variable `n`

.

It then calls the `_sum()`

function, passing in `arr`

and `n`

as arguments. The function then finds the sum of elements of array and assigns to variable ans.

Finally, the program uses the `print()`

function to display the sum of the elements in the array. The output of the program will be a single line of text:

1 2 3 |
Sum of the array is 179 |

In this example, the `_sum(arr, n)`

is calling the `sum()`

function with `arr`

as argument and returning the sum of all the elements in the array, which is `179`

and it is then printed using the print statement.

### How to to Check if a Number is Positive, Negative or 0 in Python

1 2 3 4 5 6 7 8 9 |
num = float(input("Enter a number: ")) if num > 0: print("Positive number") elif num == 0: print("Zero") else: print("Negative number") |

This program takes a single input from the user, which is expected to be a decimal number (float). It then uses an `if-elif-else`

statement to determine whether the number is positive, zero, or negative.

The program starts by using the `input()`

function to prompt the user to enter a number, which is then assigned to the variable `num`

. The `float()`

function is used to convert the user’s input into a floating-point number.

The program then uses an `if-elif-else`

statement to check the value of `num`

against several conditions. The `if`

statement checks whether `num`

is greater than 0. If it is, the program will print the message “Positive number” to the console. The `elif`

statement that follows checks whether `num`

is equal to 0, and if it is, the program will print the message “Zero” to the console. If none of these conditions are met, the program will execute the code in the `else`

block, which will print the message “Negative number” to the console.

The output of the program will depend on the input provided by the user, if user enters -5, then the output will be:

1 2 3 |
Negative number |

If user enters 5, the output will be:

1 2 3 |
Positive number |

If user enters 0, the output will be:

1 2 3 |
Zero |

The program checks for the user input number if it is greater than 0, equal to zero or less than 0. Based on the input, it will print the appropriate output as Positive number, Zero or Negative number.

### How to Check if a Number is Odd or Even in Python

1 2 3 4 5 6 7 8 9 10 |
# Python program to check if the input number is odd or even. # A number is even if division by 2 give a remainder of 0. # If remainder is 1, it is odd number. num = int(input("Enter a number: ")) if (num % 2) == 0: print("{0} is Even".format(num)) else: print("{0} is Odd".format(num)) |

This program takes a single input from the user, which is expected to be an integer. It then uses an `if-else`

statement to determine whether the number is even or odd.

The program starts by using the `input()`

function to prompt the user to enter a number, which is then assigned to the variable `num`

. The `int()`

function is used to convert the user’s input into an integer.

The program then uses an `if-else`

statement to check the value of `num`

against a single condition. The condition is checking whether `num % 2`

is equal to 0 or not. The modulus operator `%`

returns the remainder after division, so `num % 2`

will give a remainder of 0 if `num`

is even, and a remainder of 1 if `num`

is odd.

If the remainder is 0, the program will print the message “{0} is Even” to the console. If the remainder is 1, program will print the message “{0} is Odd” to the console. This is done by using string formatting and the `format()`

method to substitute the value of `num`

into the placeholders (`{0}`

) in the string.

The output of the program will depend on the input provided by the user. If user enters 4, the output will be

1 2 3 |
4 is Even |

If user enters 5, the output will be

1 2 3 |
5 is Odd |

This program is using simple mathematical logic of dividing a number by 2, if it gives a remainder of zero then it is an even number otherwise it is an odd number. Using input() function, it is taking input from the user and then using if-else statements it is printing the output if the number is even or odd.

### How to Check Leap Year in Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
# Python program to check if the input year is a leap year or not year = int(input("Enter a year: ")) if (year % 4) == 0: if (year % 100) == 0: if (year % 400) == 0: print("{0} is a leap year".format(year)) else: print("{0} is not a leap year".format(year)) else: print("{0} is a leap year".format(year)) else: print("{0} is not a leap year".format(year)) |

This program takes an input year from the user and checks whether it is a leap year or not.

A leap year is a year that is divisible by 4, except for end-of-century years which must be divisible by 400. So, this program uses the modulo operator (`%`

) to check if the year is divisible by 4, 100, and 400.

The first if statement checks if the year is divisible by 4, using the modulo operator. If it is, then the program goes to the next step.

The second if statement checks if the year is divisible by 100. If it is, the program goes to the next step, otherwise it prints that the input year is a leap year.

The third and final if statement checks if the year is divisible by 400. If it is, then the program prints that the input year is a leap year. If not, then it prints that it is not a leap year.

For example, if the user enters the year 2000, the program would output: “2000 is a leap year” 2000 is divisible by 4, and by 100, and by 400.

If the user enters the year 1999, the program would output: “1999 is not a leap year” 1999 is divisible by 4 but not divisible by 100.

It is important to note that this program does not check for negative values of year or for years before the gregorian calender.

The output of this program would depend on the input provided by the user. When the program runs, it prompts the user to enter a year and it will check whether the year is a leap year or not. It will then output a message stating whether the year is a leap year or not based on the results of the calculations performed in the if-else statements.

Example:

Input: Enter a year: 2000

Output: 2000 is a leap year

Another example: Input: Enter a year: 1999

Output: 1999 is not a leap year

Note that this program does not check for invalid input such as negative numbers, letters or other special characters. It will crash for such inputs. If you want the program to handle invalid input and give a proper error message, you can put it inside try-except block or use input validation method to check for valid inputs.

### How to Find the Largest Among Three Numbers in Python

This program takes three input numbers from the user and then uses if-elif-else statements to determine which of the three numbers is the largest.

The program starts by asking the user to input three numbers, which are then stored in the variables `num1`

, `num2`

, and `num3`

.

The first if statement checks if `num1`

is greater than or equal to `num2`

and also greater than or equal to `num3`

. If both conditions are true, then the variable `largest`

is set to `num1`

.

The second elif statement checks if `num2`

is greater than or equal to `num1`

and also greater than or equal to `num3`

. If both conditions are true, then the variable `largest`

is set to `num2`

.

The else statement is executed if both if and elif conditions are false, which means that `num3`

is the largest number.

Then the program prints a message with the largest number along with all input numbers.

For example, if the user enters 3, 4, and 2 as the three numbers, the program would output: “The largest number between 3.0 , 4.0 and 2.0 is 4.0”

It is important to note that the program input is not validating the inputs, and the program will fail if non-numeric values are entered and the input is expected to be float but if the user enters the number in int format it will also fail.

If you would like to handle such cases then you can put the code inside try-except block and check for valid inputs using input validation method.

The output of this program would depend on the input provided by the user.

When the program runs, it prompts the user to enter three numbers, and it then uses if-elif-else statements to determine which of the three numbers is the largest.

It will then output a message with the largest number along with the input numbers.

Example:

Input: Enter first number: 45 Enter second number: 67 Enter third number: 32

Output: The largest number between 45.0 , 67.0 and 32.0 is 67.0

Another example:

Input: Enter first number: 12 Enter second number: 7 Enter third number: 14

Output: The largest number between 12.0 , 7.0 and 14.0 is 14.0

As previously noted, the program does not check for invalid input such as letters or special characters, and it will fail if non-numeric input are provided. If you’d like the program to handle these cases, you can put the code inside try-except block and check for valid inputs using input validation method.

### How to Check Prime Number in Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
# Python program to check if the input number is prime or not num = int(input("Enter a number: ")) # prime numbers are greater than 1 if num > 1: # check for factors for i in range(2,num): if (num % i) == 0: print(num,"is not a prime number") print(i,"times",num//i,"is",num) break else: print(num,"is a prime number") # if input number is less than # or equal to 1, it is not prime else: print(num,"is not a prime number") |

This code prompts the user to enter a number, and then uses a series of conditions to determine whether the number is prime or not.

First, it checks if the input number is greater than 1, because prime numbers are greater than 1. If the number is less than or equal to 1, it immediately prints “is not a prime number” and exits the script.

If the number is greater than 1, the code enters a for loop that iterates over a range of numbers from 2 to (num-1).

Inside the loop, it checks if the input number is divisible by the current loop variable (i.e., if (num % i) == 0). If the remainder is 0, it means that the number is divisible by the current loop variable and is not prime, so it prints “is not a prime number” and the factor that the number is divisible by. After this it break out of the loop

If the loop completes without finding any factors, it means that the number is prime, so it prints “is a prime number”.

The output of the program depends on the input number that the user enters. If the user enters a prime number, the output will be “X is a prime number” (where X is the input number). If the user enters a composite number, the output will be “X is not a prime number” and it will also show the first factor which the number is divisible by.

For example, if the user enters the number 17, the output will be “17 is a prime number” because 17 is a prime number and is only divisible by 1 and 17. If user enters the number 15, the output will be “15 is not a prime number” and it will also show the first factor which is divisible by “3 times 5 is 15”

### How to Print all Prime Numbers in an Interval in Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
# Python program to display all the prime numbers within an interval # change the values of lower and upper for a different result lower = int(input("Enter lower range: ")) upper = int(input("Enter upper range: ")) print("Prime numbers between",lower,"and",upper,"are:") for num in range(lower,upper + 1): # prime numbers are greater than 1 if num > 1: for i in range(2,num): if (num % i) == 0: break else: print(num) |

This code prompts the user to enter two numbers, the lower and upper range for an interval, and then uses a nested loop structure to find and display all the prime numbers within that interval.

- The first part of the code prompts the user to enter a lower and upper range for the interval, and assigns these values to the variables
`lower`

and`upper`

respectively. - Next, it prints a message indicating the range of numbers being searched for prime numbers.
- The outer loop iterates over a range of numbers from
`lower`

to`upper`

, assigning each number to the variable`num`

- Inside this loop, it checks if the current number is greater than 1 (as prime numbers are greater than 1)
- Then there’s an inner loop, which runs from 2 to (num-1), and checks if the current number is divisible by any of the numbers in that range using if (num % i) == 0. If the remainder is 0, it means that the number is divisible by the current loop variable and is not prime, so it breaks out of the inner loop.
- If the inner loop completes without finding any factors, it means that the number is prime, so it prints the number.

The output of the program will be all the prime numbers between the lower and upper range that the user has entered. The prime numbers are separated by newline. The user can change the values of lower and upper to get a different result.

The output of the program will be all the prime numbers between the lower and upper range that the user has entered. The prime numbers are separated by newline.

For example, if the user enters the lower range as 10 and upper range as 50, the output will be:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
Prime numbers between 10 and 50 are: 11 13 17 19 23 29 31 37 41 43 47 |

It should be noted that the program does not validate if the lower value is smaller than the upper value, meaning that if a user enters the upper value smaller than the lower value, the program will give an empty output.

### How to Find the Factorial of a Number in Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
# Python program to find the factorial of a number provided by the user. num = int(input("Enter a number: ")) factorial = 1 # check if the number is negative, positive or zero if num < 0: print("Sorry, factorial does not exist for negative numbers") elif num == 0: print("The factorial of 0 is 1") else: for i in range(1,num + 1): factorial = factorial*i print("The factorial of",num,"is",factorial) |

This code prompts the user to enter a number, and then uses a series of conditions and a loop to calculate the factorial of the input number.

- First, it prompts the user to enter a number, and assigns the value to the variable
`num`

. - Next, it initializes a variable
`factorial`

to 1 - The code uses an if-elif-else statement to check if the input number is negative, zero, or positive.
- If the number is negative, the code prints a message saying “factorial does not exist for negative numbers”
- If the number is zero, the code prints “The factorial of 0 is 1”
- If the number is positive, the code enters a for loop that iterates over a range of numbers from 1 to (num + 1)
- Inside the loop, it multiplies the current value of factorial with the current loop variable and assigns the result back to factorial. This way it will keep on calculating the factorial for each iteration
- After the loop completes, it prints a message indicating the factorial of the input number.

The output of the program depends on the input number entered by the user.

- If user entered a positive number, it will print the factorial of that number
- If user entered 0, it will print “The factorial of 0 is 1”
- If user entered negative number, it will print “factorial does not exist for negative numbers”

For example, if the user enters the number 5, the output will be: “The factorial of 5 is 120”

### How to Display the multiplication Table in Python

1 2 3 4 5 6 7 8 |
# To take input from the user num = int(input("Display multiplication table of? ")) # use for loop to iterate 10 times for i in range(1, 11): print(num,'x',i,'=',num*i) |

This code prompts the user to enter a number (`num`

), and then uses a for loop to generate and display the multiplication table of the entered number.

- The first line prompts the user to enter a number and assigns it to the variable
`num`

- The code then enters a for loop that iterates over a range of numbers from 1 to 11 using
`range(1, 11)`

- Inside the loop, it calculates the product of
`num`

and the current loop variable (i) using the`*`

operator and assigns the result to`num*i`

- Then it prints the value of
`num`

, the current value of the loop variable`i`

, and the product`num*i`

using string concatenation.

The output of the program depends on the input number that the user enters. If the user enters the number 5, the output will be:

1 2 3 4 5 6 7 8 9 10 11 12 13 |
Display multiplication table of? 5 5 x 1 = 5 5 x 2 = 10 5 x 3 = 15 5 x 4 = 20 5 x 5 = 25 5 x 6 = 30 5 x 7 = 35 5 x 8 = 40 5 x 9 = 45 5 x 10 = 50 |

It shows the multiplication table of 5. The output shows `num`

and the loop variable separated by ‘x’, and the product of `num`

and the loop variable separated by ‘=’. If the user enters any other number, it will show the corresponding multiplication table.

### How to Print the Fibonacci sequence in Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
# Program to display the Fibonacci sequence up to n-th term where n is provided by the user #take input from the user nterms = int(input("How many terms? ")) # first two terms n1 = 0 n2 = 1 count = 0 # check if the number of terms is valid if nterms <= 0: print("Please enter a positive integer") elif nterms == 1: print("Fibonacci sequence upto",nterms,":") print(n1) else: print("Fibonacci sequence upto",nterms,":") while count < nterms: print(n1,end=' , ') nth = n1 + n2 # update values n1 = n2 n2 = nth count += 1 |

This code prompts the user to enter a number (`nterms`

), and then uses a series of conditions and a while loop to generate and display the Fibonacci sequence up to the `nterms`

-th term.

The Fibonacci sequence is a series of numbers in which each number is the sum of the two preceding ones, usually starting with 0 and 1.

- First, it prompts the user to enter a number (
`nterms`

) - Next, it initializes three variables:
`n1`

and`n2`

to 0 and 1 respectively, and`count`

to 0. These variables are used to generate the Fibonacci sequence. - The code then uses an if-elif-else statement to check if the input number is positive or zero or negative.
- If the number of terms is zero or negative, it prints “Please enter a positive integer”
- If the number of terms is 1, it prints the first number of the sequence (0)
- If the number of terms is greater than 1, it enters a while loop, which will continue until
`count`

is equal to`nterms`

- Inside the loop, it prints the current value of
`n1`

and add`n1`

and`n2`

and assign the value to`nth`

- then it updates the values of
`n1`

and`n2`

with the value of`nth`

- Finally, it increments the value of
`count`

by 1 - The loop will repeat until
`count`

is equal to`nterms`

, and the program will print the first`nterms`

numbers of the Fibonacci sequence.

The output of the program depends on the input number that the user enters. If the user enters the number 5, the output will be:

1 2 3 4 |
Fibonacci sequence upto 5 : 0 , 1 , 1 , 2 , 3 , |

It shows the Fibonacci sequence of upto 5 numbers, Separated by comma. If user enters 1, it will print “Fibonacci sequence upto 1 : 0” If user enters 0 or negative number, it will print “Please enter a positive integer”

### How to Check Armstrong Number in Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
# Python program to check if the number provided by the user is an Armstrong number or not # take input from the user num = int(input("Enter a number: ")) # initialize sum sum = 0 # find the sum of the cube of each digit temp = num while temp > 0: digit = temp % 10 sum += digit ** 3 temp //= 10 # display the result if num == sum: print(num,"is an Armstrong number") else: print(num,"is not an Armstrong number") |

This is the same code that I explained earlier. It prompts the user to enter a number and then uses a while loop to check if the number is an Armstrong number or not. An Armstrong number is a number that is equal to the sum of its own digits each raised to the power of the number of digits.

To check if the number is Armstrong or not, it first calculates the number of digits of the input number using a while loop that divides the number by 10 and counts the number of iterations. After that, it checks if the number is equal to the sum of each digit raised to the power of the number of digits. If the number is equal to this sum, it is an Armstrong number, otherwise, it’s not.

For example, if the user enters 153, the output will be “153 is an Armstrong number” because 1^3 + 5^3 + 3^3 = 153. If the user enters 123, the output will be “123 is not an Armstrong number”

The output of the program depends on the input number that the user enters.

- If the user enters 153, the output will be “153 is an Armstrong number”
- If the user enters 123, the output will be “123 is not an Armstrong number”

The output will be a string, which is the concatenation of the input number and whether it’s an Armstrong number or not. So the output will be of string type showing the input number and whether it is Armstrong or not, depending on the input number given by the user.

### How to Find Armstrong Number in an Interval in Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
# Program to check Armstrong numbers in certain interval # To take input from the user lower = int(input("Enter lower range: ")) upper = int(input("Enter upper range: ")) for num in range(lower, upper + 1): # order of number order = len(str(num)) # initialize sum sum = 0 # find the sum of the cube of each digit temp = num while temp > 0: digit = temp % 10 sum += digit ** order temp //= 10 if num == sum: print(num) |

This code prompts the user to enter two numbers, lower and upper range and then uses a for loop to check for all the numbers in the range (lower to upper) if they are Armstrong numbers or not.

An Armstrong number is a number that is equal to the sum of its own digits each raised to the power of the number of digits.

First, it prompts the user to enter the lower and upper range of numbers

Then, it enters a for loop that iterates over a range of numbers from `lower`

to `upper+1`

Inside the loop, it calculates the number of digits of the current number using `len(str(num))`

and assigns the value to `order`

Then it initializes a variable `sum`

to 0. This variable will be used to store the sum of the digit raised to the power of the number of digits of the current number

Then it assigns the value of `num`

to `temp`

and enters a while loop that continues until `temp`

is greater than 0.

Inside the loop, it calculates the last digit of the number using the modulus operator (`temp % 10`

) and assigns it to the variable `digit`

Then, it adds the `digit`

raised to the power of `order`

to `sum`

using the `+=`

operator

Finally, it updates the value of `temp`

to remove the last digit using floor division (`temp //= 10`

)

After that, the loop will check for next number in the range and repeat the process for all numbers till upper range.

The output of the program depends on the input number that the user enters for the range. For example, if the user enters lower range as 100 and upper range as 1000, the output will be:

1 2 3 4 5 6 |
153 370 371 407 |

It shows the Armstrong numbers between 100 and 1000. If there are no armstrong numbers in the given range, the program will output nothing.

It’s important to note that this program is not optimized for large range inputs as the running time increases rapidly as the range gets larger. The calculation of the power and the modulus operator can be expensive operations and if the range is very large it can take a long time to finish execution.

### How to Find the Sum of Natural Numbers in Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
# Python program to find the sum of natural numbers up to n where n is provided by user #to take input from the user num = int(input("Enter a number: ")) if num < 0: print("Enter a positive number") else: sum = 0 # use while loop to iterate un till zero while(num > 0): sum += num num -= 1 print("The sum is",sum) |

This code prompts the user to enter a number (`num`

), and then uses a while loop to calculate the sum of all the natural numbers up to that number.

A natural number is a positive integer, 1, 2, 3, 4, 5, 6…

First, it prompts the user to enter a number and assigns it to the variable `num`

It then uses an if-else statement to check if the number is less than zero

If the number is less than zero, it prints “Enter a positive number”

Else, it initializes a variable `sum`

to 0, which will be used to store the sum of the natural numbers.

Then it enters a while loop that continues until `num`

is greater than 0.

Inside the loop, it adds `num`

to `sum`

using the `+=`

operator.

Then it decrements the value of `num`

by 1 using `num -= 1`

After the loop completes, it prints the sum of natural numbers up to that number

The output of the program depends on the input number that the user enters. It will be an integer that indicates the sum of the natural numbers up to that number.

For example, If the user enters the number 5, the output will be “The sum is 15” (1+2+3+4+5). If the user enters 0, the output will be “The sum is 0”. If the user enters negative number, it will print “Enter a positive number”.

So the output will be a single integer, as well as a string indicating the message that “The sum is” and the number obtained by adding the natural numbers till entered number.

### How to Display Powers of 2 Using Anonymous Function in Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
# Python Program to display the powers of 2 using anonymous function #to take number of terms from user terms = int(input("How many terms? ")) # use anonymous function result = list(map(lambda x: 2 ** x, range(terms))) # display the result print("The total terms is:",terms) for i in range(terms): print("2 raised to power",i,"is",result[i]) |

This code prompts the user to enter a number (`terms`

) and then uses the `map()`

function along with a lambda function to calculate the powers of 2 up to the number of terms entered.

The `map()`

function applies a given function to all the items in an input list, and it returns an iterator that generates the output. In this case, the lambda function is used to calculate `2**x`

, where x is the current value of the input range (0 to `terms-1`

) and 2 is the base number.

The `list()`

function is used to convert the iterator returned by the `map()`

function into a list.

- First, it prompts the user to enter the number of terms and assigns it to the variable
`terms`

- It then uses the
`map()`

function along with a lambda function to calculate the powers of 2 up to the number of terms entered. - The lambda function takes the current value of the input range and raises 2 to the power of that value.
- Next, the result of the
`map()`

function is converted into a list using the`list()`

function and assigned to the variable`result`

- Then it enters a for loop that iterates over a range of numbers from 0 to
`terms-1`

- Inside the loop, it prints the current power of 2 and the corresponding value from the
`result`

list

The output of the program depends on the input number that the user enters. For example, If the user enters the number 5, the output will be:

1 2 3 4 5 6 7 8 |
The total terms is: 5 2 raised to power 0 is 1 2 raised to power 1 is 2 2 raised to power 2 is 4 2 raised to power 3 is 8 2 raised to power 4 is 16 |

This code uses Anonymous function (lambda) which is a small function without a name. Here lambda function is used as single-use function, without having to explicitly define a function using def.

So the output will be a list of integers with terms numbers showing the power of 2 raised to that term.

### How to Find Numbers Divisible by Another Number in Python

1 2 3 4 5 6 7 8 9 10 11 12 |
# Python Program to find numbers divisible by fifteen from a list using anonymous function # Take a list of numbers my_list = [300, 45, 65, 12, 77, 145, 5,] # use anonymous function to filter result = list(filter(lambda x: (x % 15 == 0), my_list)) # display the result print("Numbers divisible by 13 are",result) |

This code takes a list of numbers (`my_list`

) and uses the `filter()`

function along with a lambda function to filter out the numbers that are divisible by 15.

The `filter()`

function filters the items of an input list by applying a given function to each item and returns an iterator that generates the output. In this case, the lambda function is used to check if the current item (`x`

) is divisible by 15 (`x % 15 == 0`

). If the current item is divisible by 15, it is included in the output list, otherwise, it’s not.

- First, it takes a list of numbers and assigns it to the variable
`my_list`

- It then uses the
`filter()`

function along with a lambda function to filter out the numbers that are divisible by 15 - The lambda function takes the current item of the input list and checks if it is divisible by 15 (
`x % 15 == 0`

) - Next, the result of the
`filter()`

function is converted into a list using the`list()`

function and assigned to the variable`result`

- Finally, it prints the final list of numbers that are divisible by 15.

The output of the program will be a list of integers that are divisible by 15 from the given list.

For example, if the input list is [300, 45, 65, 12, 77, 145, 5], the output will be `[45, 105, 165, 225, 285]`

.

In this code too, like previous, Anonymous function (lambda) is used, which is a small function without a name. Here lambda function is used as single-use function, without having to explicitly define a function using def.

### How to Convert Decimal to Binary, Octal and Hexadecimal in Python

1 2 3 4 5 6 7 8 9 10 11 |
# Python program to convert decimal number into binary, octal and hexadecimal number system # Change this line for a different result dec = int(input("Enter a decimal number ")) print("The decimal value of",dec,"is:") print(bin(dec),"in binary.") print(oct(dec),"in octal.") print(hex(dec),"in hexadecimal.") |

This code prompts the user to enter a decimal number (`dec`

) and uses the built-in functions `bin()`

, `oct()`

, and `hex()`

to convert the decimal number into binary, octal and hexadecimal number systems respectively.

The `bin()`

function takes an integer as an argument and returns a string that represents the binary equivalent of the decimal number. The `oct()`

function takes an integer as an argument and returns a string that represents the octal equivalent of the decimal number. The `hex()`

function takes an integer as an argument and returns a string that represents the hexadecimal equivalent of the decimal number.

- First, it prompts the user to enter a decimal number and assigns it to the variable
`dec`

- Then it uses the
`bin()`

,`oct()`

, and`hex()`

functions to convert the decimal number into binary, octal, and hexadecimal number systems respectively - Next, it prints the decimal value along with its binary, octal, and hexadecimal equivalents

The output of the program will be a decimal number along with its equivalent in binary, octal and hexadecimal number systems

For example, if the input decimal number is 42, the output will be:

1 2 3 4 5 6 |
The decimal value of 42 is: 0b101010 in binary. 0o52 in octal. 0x2a in hexadecimal. |

Here `0b`

is prefixed for binary, `0o`

for octal and `0x`

for hexadecimal representation.

### How to Find ASCII Value of Character in Python

1 2 3 4 5 6 7 8 |
# Program to find the ASCII value of the given character #to take character from user c = input("Enter a character: ") print("The ASCII value of '" + c + "' is",ord(c)) |

This code prompts the user to enter a character and uses the built-in function `ord()`

to find the ASCII value of that character.

The `ord()`

function takes a character as an argument and returns an integer representing the Unicode code point of that character.

- First, it prompts the user to enter a character and assigns it to the variable
`c`

- Then it uses the
`ord()`

function to find the ASCII value of that character - Next, it prints the ASCII value along with the character by concatenating the string.

The output of the program will be a character along with its ASCII value

For example, if the input character is ‘a’, the output will be:

1 2 3 |
The ASCII value of 'a' is 97 |

It takes any character and returns its corresponding ASCII value.

### How to Find HCF or GCD in Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
# Python program to find the H.C.F of two input number # define a function def computeHCF(x, y): # choose the smaller number if x > y: smaller = y else: smaller = x for i in range(1, smaller+1): if((x % i == 0) and (y % i == 0)): hcf = i return hcf # take input from the user num1 = int(input("Enter first number: ")) num2 = int(input("Enter second number: ")) print("The H.C.F. of", num1,"and", num2,"is", computeHCF(num1, num2)) |

This code prompts the user to enter two numbers and uses a user-defined function `computeHCF()`

to find the highest common factor (H.C.F) of those two numbers.

The `computeHCF()`

function takes two arguments `x`

and `y`

and uses a for loop to iterate over a range of numbers from 1 to the smaller of the two input numbers. Inside the loop, it checks if the current number is a common factor of both input numbers by using the modulus operator `%`

. If a number is a common factor, it assigns it to the variable `hcf`

and continues the loop. Finally, it returns the value of `hcf`

as the H.C.F of the two input numbers.

- First, it prompts the user to enter two numbers, assigns them to the variables
`num1`

and`num2`

- Then it calls the
`computeHCF()`

function and pass`num1`

and`num2`

as argument to the function - Inside the function, it first finds the smaller number and assigns it to
`smaller`

- Next, it enters a for loop that iterates over a range of numbers from 1 to the smaller of the two input numbers.
- Inside the loop, it checks if the current number is a common factor of both input numbers. If yes, it assigns it to hcf and continue the loop.
- After the loop, it returns the value of hcf as the H.C.F of the two input numbers.
- Finally, it prints the H.C.F of the two numbers

The output of the program will be an integer which is the highest common factor of the two input numbers

### How to Find LCM in Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
# Python Program to find the L.C.M. of two input number # define a function def lcm(x, y): """This function takes two integers and returns the L.C.M.""" # choose the greater number if x > y: greater = x else: greater = y while(True): if((greater % x == 0) and (greater % y == 0)): lcm = greater break greater += 1 return lcm #to take input from the user num1 = int(input("Enter first number: ")) num2 = int(input("Enter second number: ")) print("The L.C.M. of", num1,"and", num2,"is", lcm(num1, num2)) |

This code prompts the user to enter two numbers and uses a user-defined function `lcm()`

to find the least common multiple (L.C.M) of those two numbers.

The `lcm()`

function takes two arguments `x`

and `y`

and first it finds the greater number and assigns it to the variable `greater`

. Then, it enters an infinite loop and checks if `greater`

is divisible by both `x`

and `y`

using the modulus operator `%`

. If `greater`

is divisible by both numbers, it assigns it to the variable `lcm`

and breaks the loop. If not, it increments the value of `greater`

by 1 and continues the loop. Finally, it returns the value of `lcm`

as the L.C.M of the two input numbers.

- First, it prompts the user to enter two numbers, assigns them to the variables
`num1`

and`num2`

- Then it calls the
`lcm()`

function and pass`num1`

and`num2`

as argument to the function - Inside the function, it first finds the greater number and assigns it to
`greater`

- Next, it enters an infinite loop that and check whether
`greater`

is divisible by both`x`

and`y`

using the modulus operator`%`

- If
`greater`

is divisible by both numbers, it assigns it to the variable`lcm`

and breaks the loop. - If not, it increments the value of
`greater`

by 1 and continues the loop. - After the loop, it returns the value of lcm as the L.C.M of the two input numbers.
- Finally, it prints the L.C.M of the two numbers

The output of

the program will be an integer which is the least common multiple of the two input numbers.

It is worth noting that the L.C.M of two numbers can be found by multiplying the two numbers and then dividing the result by their H.C.F. This way is more efficient than the current implementation.

Additionally, It is also worth noting that this implementation can also be optimised by using mathematical formula for L.C.M, which is LCM(a,b) = (a*b)/hcf(a,b), where hcf is the highest common factor. This way it would not require an infinite loop.

### How to Find Factors of Number in Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
# Python Program to find the factors of a number # define a function def print_factors(x): # This function takes a number and prints the factors print("The factors of",x,"are:") for i in range(1, x + 1): if x % i == 0: print(i) #to take input from the user num = int(input("Enter a number: ")) print_factors(num) |

This code prompts the user to enter a number and uses a user-defined function `print_factors()`

to find and display the factors of that number.

The `print_factors()`

function takes one argument `x`

and uses a for loop to iterate over a range of numbers from 1 to the input number. Inside the loop, it checks if the current number is a factor of the input number by using the modulus operator `%`

. If a number is a factor, it is printed.

- First, it prompts the user to enter a number, assigns it to the variable
`num`

- Then it calls the
`print_factors()`

function and passes`num`

as an argument to the function - Inside the function, it enters a for loop that iterates over a range of numbers from 1 to the input number.
- Inside the loop, it checks if the current number is a factor of the input number. If yes, it prints it.
- After the loop, all factors of the number have been printed.

The output of the program will be a list of integers, the factors of the input number.

### How to Make a Simple Calculator in Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
# Program make a simple calculator that can add, subtract, multiply and divide using functions # This function adds two numbers def add(x, y): return x + y # This function subtracts two numbers def subtract(x, y): return x - y # This function multiplies two numbers def multiply(x, y): return x * y # This function divides two numbers def divide(x, y): return x / y print("Select operation.") print("1.Add") print("2.Subtract") print("3.Multiply") print("4.Divide") # Take input from the user choice = input("Enter choice(1/2/3/4):") num1 = int(input("Enter first number: ")) num2 = int(input("Enter second number: ")) if choice == '1': print(num1,"+",num2,"=", add(num1,num2)) elif choice == '2': print(num1,"-",num2,"=", subtract(num1,num2)) elif choice == '3': print(num1,"*",num2,"=", multiply(num1,num2)) elif choice == '4': print(num1,"/",num2,"=", divide(num1,num2)) else: print("Invalid input") |

This code creates a simple calculator that can perform four basic arithmetic operations: addition, subtraction, multiplication, and division.

The program defines four functions: `add()`

, `subtract()`

, `multiply()`

, and `divide()`

, each function takes two arguments, performs a specific arithmetic operation and returns the result. The program then prompts the user to select an operation from a menu of options using a series of print statements.

Once the user has selected an operation, the program prompts the user to enter two numbers, then uses an if-elif block to determine which operation the user selected, and then calls the appropriate function, passing the user-entered numbers as arguments.

The output of the program will be a simple statement with the result of the arithmetic operation applied on the two numbers entered by the user.

For example, if the user inputs “1” as the choice, and “5” and “6” as the two numbers, the program will output “5 + 6 = 11”. And if the user inputs 4 and 3 as the two numbers and divide as the option it will print the division of 4 and 3 , 4/3.

In case if the user inputs any other value then 1,2,3 and 4 it will print Invalid input, as the input is not valid and not present in the options provided to the user.

### How to Display Calendar in Python

1 2 3 4 5 6 7 8 9 10 11 12 13 |
# Python program to display calendar of given month of the year # import module import calendar # To ask month and year from the user yy = int(input("Enter year: ")) mm = int(input("Enter month: ")) # display the calendar print(calendar.month(yy, mm)) |

This code uses the `calendar`

module in Python to display the calendar of a given month of a given year. The code first prompts the user to enter the year and month for which they want to see the calendar, then it stores those values in the variables `yy`

and `mm`

.

The `calendar.month()`

function is then used to display the calendar. This function takes two arguments: the year and the month, and it returns a multi-line string that represents the calendar for that month. The returned string is then passed to the `print()`

function to display the calendar on the screen.

The `calendar.month()`

function is responsible for drawing the calendar. This function will return the month’s calendar as a multi-line string, for the given year and month, ready for printing.

For example, if the user inputs “2022” as the year and “6” as the month, the program will output a calendar for the month of June in the year 2022, something similar to this

1 2 3 4 5 6 7 8 9 |
June 2022 Mo Tu We Th Fr Sa Su 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |

It could be used to generate the calendar of any month and any year which the user wants to see.

### How to Display Fibonacci Sequence Using Recursion in Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
# Python program to display the Fibonacci sequence up to n-th term using recursive functions def recur_fibo(n): """Recursive function to print Fibonacci sequence""" if n <= 1: return n else: return(recur_fibo(n-1) + recur_fibo(n-2)) #to take input from the user nterms = int(input("How many terms? ")) # check if the number of terms is valid if nterms <= 0: print("Plese enter a positive integer") else: print("Fibonacci sequence:") for i in range(nterms): print(recur_fibo(i)) |

This program uses a recursive function called `recur_fibo(n)`

to generate the Fibonacci sequence. The function takes an integer argument `n`

which represents the number of terms to be generated in the sequence.

The function checks if the input value of `n`

is less than or equal to 1, if so, it returns the value of `n`

as the first and second terms of the Fibonacci sequence are 0 and 1 respectively. If `n`

is greater than 1, the function calls itself with the values (n-1) and (n-2) as arguments and returns the sum of these recursive calls.

The program then takes user input for the number of terms to be generated in the Fibonacci sequence. The program checks if the input is a positive integer, if not it prompts the user to enter a positive integer. If the input is valid the program uses a for loop to iterate from 0 to `nterms`

and calls the `recur_fibo(i)`

function at each iteration. Finally it prints the output as Fibonacci sequence

When the program runs, it will prompt the user to enter the number of terms to be generated in the sequence, and then it will display the Fibonacci sequence with that many number of terms. This will be done by calling the function `recur_fibo(i)`

inside the for loop and printing the returned value of the function.

For the output, since program uses recursion, the output will be the Fibonacci sequence. The first two terms will be 0 and 1, and the remaining terms will be the sum of the previous two terms. If you give input as 10, the output will be Fibonacci sequence from 0-9, that is 0,1,1,2,3,5,8,13,21,34.

### How to Find Sum of Natural Numbers Using Recursion in Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
# Python program to find the sum of natural numbers up to n using recursive function def recur_sum(n): """Function to return the sum of natural numbers using recursion""" if n <= 1: return n else: return n + recur_sum(n-1) #to take input from the user num = int(input("Enter a number: ")) if num < 0: print("Enter a positive number") else: print("The sum is",recur_sum(num)) |

The above program uses a recursive function `recur_sum(n)`

to find the sum of natural numbers up to a given number `n`

. The function takes one parameter `n`

which is the upper limit of the natural numbers to be added.

When the program is run, it first prompts the user to enter a number. The entered number is stored in the variable `num`

.

The program checks if the entered number is less than 0, If `num`

is less than 0, it prints a message “Enter a positive number”. If `num`

is greater than 0, it calls the recursive function `recur_sum(n)`

and passes the entered number `num`

as the argument. The function is called recursively until the base case is reached which is when `n`

is less than or equal to 1.

The base case of the function returns the value of n as the sum of natural numbers. In each recursive call, the function adds the current value of n and the previous value returned by the function and returns the result.

Finally, the program prints the final returned value which is the sum of natural numbers up to the entered number.

When the program runs it will prompt user to input a number and the program will return the sum of natural numbers upto that number.

The output of the program will be a single line that shows the sum of natural numbers up to the input number entered by the user. for example, if the user inputs the number 5, the output will be “The sum is 15” because 1 + 2 + 3 + 4 + 5 = 15

### How to Find Factorial of Number Using Recursion in Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
# Python program to find the factorial of a number using recursion def recur_factorial(n): """Function to return the factorial of a number using recursion""" if n == 1: return n else: return n*recur_factorial(n-1) #to take input from the user num = int(input("Enter a number: ")) # check is the number is negative if num < 0: print("Sorry, factorial does not exist for negative numbers") elif num == 0: print("The factorial of 0 is 1") else: print("The factorial of",num,"is",recur_factorial(num)) |

This program is used to find the factorial of a given number using recursion. The program takes an input from the user, and assigns it to the variable `num`

.

A function `recur_factorial(n)`

is defined that takes an input `n`

, which is the number for which we are supposed to find the factorial. The function first checks if `n`

is 1, if it is then it returns n as the factorial of n, because the factorial of 1 is 1. If n is not equal to 1, then it returns n multiplied by the factorial of n-1, which is the recursive step.

Then the program checks if the input number is negative, and if it is, it prints an error message. If the input number is 0, it prints that the factorial of 0 is 1. If the input number is positive, it calls the function recur_factorial() on the input number and prints the output.

It will output the factorial of entered number by user in the given format.

The output of the program will be the factorial of the number provided by the user, as long as it’s a positive number. In case of a negative or zero input, the program will print error or special case message respectively.

### How to Convert Decimal to Binary Using Recursion in Python

1 2 3 4 5 6 7 8 9 10 11 12 |
def convertToBinary(n): # Function to print binary number for the input decimal using recursion if n > 1: convertToBinary(n//2) print(n % 2,end = '') # decimal number dec = int(input("Enter a number:")) convertToBinary(dec) |

This code is a Python program that converts a decimal number to binary using recursion. The `convertToBinary`

function takes an integer argument `n`

and uses recursion to convert it to binary.

The function works by first checking if `n`

is greater than 1. If it is, the function calls itself with the argument `n//2`

, which is equivalent to `n`

divided by 2 (integer division). The function then uses the modulus operator `%`

to find the remainder when `n`

is divided by 2, which will be either 0 or 1. This remainder is then printed using the `print`

function with the `end`

parameter set to an empty string, which means that the output will not be followed by a newline character.

The program prompts the user to enter a decimal number, which is then passed as an argument to the `convertToBinary`

function. When the function finishes running, the binary equivalent of the decimal number will be printed on the screen.

The output will be the binary representation of the entered decimal number.

### How to Add Two Matrices in Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
# Program to add two matrices using nested loop X = [[5, 7, 13], [41, 5, 16], [47, 5, 19]] Y = [[5 ,5 ,1], [6 ,4 ,3], [4 ,4 ,9]] result = [[0,0,0], [0,0,0], [0,0,0]] # iterate through rows for i in range(len(X)): # iterate through columns for j in range(len(X[0])): result[i][j] = X[i][j] + Y[i][j] for r in result: print(r) |

This code first defines two matrices `X`

and `Y`

as a list of lists. Then a variable `result`

is defined as a list of lists containing three rows and three columns of zeroes. This variable will be used to store the result of the matrix addition.

The program then uses nested loops to iterate through the rows and columns of the matrices. In each iteration of the nested loops, it performs the following action: `result[i][j] = X[i][j] + Y[i][j]`

This adds the element at position `i, j`

in matrix `X`

to the element at position `i, j`

in matrix `Y`

, and assigns the result to the corresponding position in the `result`

matrix.

Finally, the result matrix is printed by iterating over it, and inside the inner loop, each sublist of matrix is printed

Another way of adding two matrix is using numpy. numpy has a function called add() which add two matrices element wise. Here is an example,

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
import numpy as np X = np.array([[5, 7, 13], [41, 5, 16], [47, 5, 19]]) Y = np.array([[5 ,5 ,1], [6 ,4 ,3], [4 ,4 ,9]]) result = np.add(X, Y) print(result) |

In this example, instead of using nested loop the numpy add function is used to add the matrices. Here you can see the simplicity and readability of the code is improved.

1 2 3 4 5 |
[10 12 14] [47 9 19] [51 9 28] |

This is the result of matrix addition of X and Y element wise. Similarly, in the second code snippet, the result will also be the matrix addition of X and Y element wise and would have the same shape as X and Y.

### How to Transpose a Matrix in Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
# Program to transpose a matrix using nested loop X = [[12,7], [42 ,5], [32 ,8]] result = [[0,0,0], [0,0,0]] # iterate through rows for i in range(len(X)): # iterate through columns for j in range(len(X[0])): result[j][i] = X[i][j] for r in result: print(r) |

The matrix `X`

is defined as a list of lists, with each inner list representing a row of the matrix.

The program defines a variable `result`

, which is initialized as a list of lists containing two rows and three columns of zeroes. This variable will be used to store the transposed matrix.

The outer loop uses the `range`

function to iterate over the rows of the matrix, with the variable `i`

representing the current row. The inner loop uses the `range`

function to iterate over the columns of the matrix, with the variable `j`

representing the current column.

In each iteration of the nested loops, the program performs the following action: `result[j][i] = X[i][j]`

This takes the element at position `i, j`

in matrix `X`

and assigns it to the position `j, i`

in the `result`

matrix. Because this is done for all elements in the matrix, this operation effectively swaps the rows and columns of the matrix, which is the definition of transposition.

Then the transposed matrix is printed by iterating over it, and inside the inner loop, each sublist of matrix is printed.

So, the output will be the transposed version of X with rows becoming columns and columns becoming rows. It will have same number of rows as the number of columns in the matrix X and same number of columns as the number of rows in the matrix X

### How to Multiply Two Matrices in Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
# Program to multiply two matrices using nested loops # 3x3 matrix X = [[12,7,3], [4 ,5,6], [7 ,8,9]] # 3x4 matrix Y = [[5,8,1,2], [6,7,3,0], [4,5,9,1]] # result is 3x4 result = [[0,0,0,0], [0,0,0,0], [0,0,0,0]] # iterate through rows of X for i in range(len(X)): # iterate through columns of Y for j in range(len(Y[0])): # iterate through rows of Y for k in range(len(Y)): result[i][j] += X[i][k] * Y[k][j] for r in result: print(r) |

The matrices `X`

and `Y`

are defined as a list of lists, with each inner list representing a row of the matrix.

The program defines a variable `result`

, which is initialized as a list of lists containing three rows and four columns of zeroes. This variable will be used to store the result of the matrix multiplication.

The outermost loop uses the `range`

function to iterate over the rows of matrix `X`

. The variable `i`

represents the current row of matrix `X`

being processed.

The next inner loop uses the `range`

function to iterate over the columns of matrix `Y`

. The variable `j`

represents the current column of matrix `Y`

being processed.

The innermost loop uses the `range`

function to iterate over the rows of matrix `Y`

. The variable `k`

represents the current row of matrix `Y`

being processed.

In each iteration of the nested loops, the program performs the following action: `result[i][j] += X[i][k] * Y[k][j]`

This performs a dot product operation of the current row of matrix `X`

and the current column of matrix `Y`

being processed. And the product is accumulated in result[i][j], which is the same position in the resulting matrix.

Finally, the resulting matrix is printed by iterating over it, and inside the inner loop, each sublist of matrix is printed.

It’s important to note that this code will only work when number of columns of X is equal to the number of rows of Y and the resulting matrix will have shape of number of rows of X and number of columns of Y.

### How to Check Whether a String is Palindrome or Not in Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
# Program to check if a string # is palindrome or not # change this value for a different output my_str = 'ababa' # make it suitable for caseless comparison my_str = my_str.casefold() # reverse the string rev_str = reversed(my_str) # check if the string is equal to its reverse if list(my_str) == list(rev_str): print(my_str," is palindrome") else: print(my_str," is not palindrome") |

A palindrome is a word, phrase, number, or other sequence of characters that reads the same forward and backward (ignoring spaces, punctuation, and capitalization).

The program first defines a variable `my_str`

which contains the string to be checked. It then makes it suitable for caseless comparison by using the `casefold()`

method.

Next, it creates a new variable `rev_str`

which is the reversed version of `my_str`

by using the `reversed()`

function which returns an iterator, so it needs to be casted to list.

Finally, the program checks if the original string is equal to the reversed string by comparing them as lists. If they are equal, it prints that the string is a palindrome. If they are not equal, it prints that the string is not a palindrome.

In this case, ‘ababa’ will be a palindrome because if you read it in forward or backward direction it will be same. The output will be:

1 2 3 |
ababa is palindrome |

### How to Remove Punctuations From a String in Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
# define punctuation punctuations = '''!()-[]{};:'"\,<>./?@#$%^&*_~''' # To take input from the user my_str = input("Enter a string: ") # remove punctuation from the string no_punct = "" for char in my_str: if char not in punctuations: no_punct = no_punct + char # display the unpunctuated string print(no_punct) |

This code is a Python program that removes punctuation marks from a given string.

The program first defines a string variable `punctuations`

which contains a list of punctuation marks that are to be removed from the input string.

It then prompts the user to enter a string which is stored in the variable `my_str`

.

The program then creates an empty string `no_punct`

which will be used to store the modified string without punctuation marks.

It then uses a for loop to iterate through each character in `my_str`

. For each character, the program checks if it is present in the `punctuations`

variable. If it is not present, the character is added to the `no_punct`

variable, otherwise it’s skipped.

Finally, the unpunctuated string is displayed using the print function. This will output the input string without any punctuation marks.

This code will remove all the punctuations from the given string. The output will be the string without any punctuation marks.

### How to Sort Words in Alphabetic Order in Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
# Program to sort alphabetically the words form a string provided by the user #to take input from the user my_str = input("Enter a string: ") # breakdown the string into a list of words words = my_str.split() # sort the list words.sort() # display the sorted words print("The sorted words are:") for word in words: print(word) |

This program takes a string input from the user and breaks it down into a list of words by using the `split()`

method. The resulting list is then sorted alphabetically using the `sort()`

method. The program then iterates through the sorted list and prints each word on a new line.

The program starts by prompting the user to enter a string, which is stored in the variable `my_str`

using the `input()`

function.

Next, the program uses the `split()`

method to break down the input string into a list of words. The `split()`

method, by default, splits a string at whitespace characters, so it separates the words in the input string into a list.

The `sort()`

method is then used to sort the list of words alphabetically.

The program then uses a `for`

loop to iterate through the sorted list of words, and it prints each word on a new line using the `print()`

function.

And the final output of this program is a sorted string words in alphabetically.

### How to Illustrate Different Set Operations in Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
# Program to perform different set operations like in mathematics # define three sets E = {0, 2, 4, 6, 8}; N = {1, 2, 3, 4, 5}; # set union print("Union of E and N is",E | N) # set intersection print("Intersection of E and N is",E & N) # set difference print("Difference of E and N is",E - N) # set symmetric difference print("Symmetric difference of E and N is",E ^ N) |

This program demonstrates how to perform different set operations in Python. Here’s what the code does:

The program starts by defining three sets: `E`

, `N`

. `E`

is defined as {0, 2, 4, 6, 8} and `N`

is defined as {1, 2, 3, 4, 5}.

Next, the program uses the union operator `|`

to find the union of sets `E`

and `N`

, and the result is stored in the variable `Union`

.

The program then uses the intersection operator `&`

to find the intersection of sets `E`

and `N`

, and the result is stored in the variable `Intersection`

.

Then, the program uses the difference operator `-`

to find the difference between the sets `E`

and `N`

, and the result is stored in the variable `Difference`

.

Finally, the program uses the symmetric difference operator `^`

to find the symmetric difference between sets `E`

and `N`

, and the result is stored in the variable `Symmetric Difference`

The program prints the results of the set operations using the `print()`

function.

The final output of the program will be the Union, Intersection, Difference and symmetric difference of the given two sets.

### How to Count the Number of Each Vowel in Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
# Program to count the number of each vowel in a string # string of vowels vowels = 'aeiou' #to take input from the user ip_str = input("Enter a string: ") # make it suitable for caseless comparisions ip_str = ip_str.casefold() # make a dictionary with each vowel a key and value 0 count = {}.fromkeys(vowels,0) # count the vowels for char in ip_str: if char in count: count[char] += 1 print(count) |

This program takes a string input from the user, and it uses a dictionary to count the number of each vowel that appears in the input string. Here’s what the code does, step by step:

The program starts by defining a string of vowels called `vowels`

, which contains the characters ‘a’, ‘e’, ‘i’, ‘o’, and ‘u’.

It then prompts the user to enter a string, which is stored in the variable `ip_str`

using the `input()`

function.

Next, the `casefold()`

method is used to convert the input string to lowercase so that the program can perform case-insensitive comparisons.

The program then creates an empty dictionary called `count`

using the `fromkeys()`

method and passing `vowels`

as the argument. This method creates a dictionary containing the vowels as keys and assigns 0 as the value for each key.

Next, the program uses a `for`

loop to iterate through each character in the input string, and it uses an `if`

statement to check if the character is a vowel by checking if it exists in the `count`

dictionary.

If the character is a vowel, it increments the value associated with the key for that vowel in the `count`

dictionary.

The final step, `print(count)`

will give the output of the number of occurrences of each vowel in the input string.