# Factorial program in python using recursion

Last updated 3 years, 4 months ago | 1292 views

Tags:- Python

# Python | Program to find factorial of a number using recursive function

This is an example of how to find the factorial of a number in python using a recursive function.

The factorial of a number is a product of all the positive integers less than or equal to that number.
For example, the factorial of 5 is = 5x4x3x2x1 = 120

Factorial is not defined for negative integers, and the factorial of zero is one, 0! = 1.

``````# recursive function for factorial
def fact(n):
if n == 1:
return n
else:
return n*fact(n-1)

# accept input from user
n = int(input('Enter no:.'))

# check condition for different input
if n < 0:
print(f"Sorry, factorial does not exist for {n}, negative number")
elif n == 0:
print("The factorial of 0 is 1")
else:
print(fact(n))``````

Output for the above code

```>>>
====================== RESTART: E:\py\factorial.py ======================
Enter no.:5
120
>>>
====================== RESTART: E:\py\factorial.py ======================
Enter no.:0
The factorial of 0 is 1
>>>
====================== RESTART: E:\py\factorial.py ======================
Enter no.:-5
Sorry, factorial does not exist for -5, negative number```

# Python | Pass Statement

The pass statement is used as a placeholder for future code. It represents a null operation in Python. It is generally used for the purpose of filling up empty blocks of code which may execute during runtime but has yet to be written.

``````def myfunction():
pass``````

# Python | Generate random numbers

Python provides a module called random using which we can generate random numbers. e.g: print(random.random())

We have to import a random module and call the random() method as shown below:

`````` import random

print(random.random())``````

The random() method generates float values lying between 0 and 1 randomly.

To generate customized random numbers between specified ranges, we can use the randrange() method
Syntax: randrange(beginning, end, step)

``````import random

print(random.randrange(5,100,2))``````

# Python | Lambda function

A lambda function is a small anonymous function. This function can have any number of parameters but, can have just one statement.

Syntex:
lambda arguments : expression

``````a = lambda x,y : x+y

print(a(5, 6))``````

It also provides a nice way to write closures. With that power, you can do things like this.

``````def adder(x):
return lambda y: x + y

As you can see from the snippet of Python, the function adder takes in an argument x and returns an anonymous function, or lambda, that takes another argument y. That anonymous function allows you to create functions from functions. This is a simple example, but it should convey the power lambdas and closures have.

# Python | swapcase() Function

It is a string's function that converts all uppercase characters into lowercase and vice versa. It automatically ignores all the non-alphabetic characters.

``````string = "IT IS IN LOWERCASE."

print(string.swapcase())  ``````

# Python | strip() Function | Remove whitespaces from a string

To remove the whitespaces and trailing spaces from the string, Python provides a strip([str]) built-in function. This function returns a copy of the string after removing whitespaces if present. Otherwise returns the original string.

``````string = "  Python "

print(string.strip())  ``````

# Python | enumerate() Function

The enumerate() function is used to iterate through the sequence and retrieve the index position and its corresponding value at the same time.

``````lst = ["A","B","C"]

print (list(enumerate(lst)))

#[(0, 'A'), (1, 'B'), (2, 'C')]``````

# Python | filter(), map(), and reduce() Functions

• filter()  function accepts two arguments, a function and an iterable, where each element of the iterable is filtered through the function to test if the item is accepted or not.
``````>>> set(filter(lambda x:x>4, range(7)))

# {5, 6}

``````

• map() function calls the specified function for each item of an iterable and returns a list of result

``````>>> set(map(lambda x:x**3, range(7)))

# {0, 1, 64, 8, 216, 27, 125}``````

• reduce() function reduces a sequence pair-wise, repeatedly until we arrive at a single value..

``````>>> reduce(lambda x,y:y-x, [1,2,3,4,5])

# 3
``````

Let’s understand this:

2-1=1
3-1=2
4-2=2
5-2=3

Hence, 3.

# Python | namedtuple

A namedtuple will let us access a tuple’s elements using a name/label. We use the function namedtuple() for this, and import it from collections.

``````>>> from collections import namedtuple

#format
>>> result=namedtuple('result','Physics Chemistry Maths')

#declaring the tuple
>>> Chris=result(Physics=86,Chemistry=92,Maths=80)

>>> Chris.Chemistry
# 92``````

# Write a code to add the values of same keys in two different dictionaries and return a new dictionary.

We can use the Counter method from the collections module

``````from collections import Counter

dict1 = {'a': 5, 'b': 3, 'c': 2}
dict2 = {'a': 2, 'b': 4, 'c': 3}

new_dict = Counter(dict1) + Counter(dict2)

print(new_dict)
# Print: Counter({'a': 7, 'b': 7, 'c': 5})``````

# Python In-place swapping of two numbers

Python | In-place swapping of two numbers

``````>>> a, b = 10, 20
>>> print(a, b)
10 20

>>> a, b = b, a
>>> print(a, b)
20 10
``````

# Reversing a String in Python

Python | Reversing a String

``````>>> x = 'PythonWorld'
>>> print(x[: : -1])
dlroWnohtyP``````

# Python join all items of a list to convert into a single string

Python | Join all items of a list to convert into a single string

``````>>> x = ["Python", "Online", "Training"]
>>> print(" ".join(x))
Python Online Training``````

# python return multiple values from functions

Python | Return multiple values from functions

``````>>> def A():
return 2, 3, 4

>>> a, b, c = A()

>>> print(a, b, c)
2 3 4``````

# Python Print String N times

Python | Print String N times

``````>>> s = 'Python'
>>> n = 5

>>> print(s * n)
PythonPythonPythonPythonPython``````

# Python check the memory usage of an object

Python | Check the memory usage of  an object

``````>>> import sys
>>> x = 100

>>> print(sys.getsizeof(x))
28``````