The average or arithmetic mean of a collection of numbers is calculated by adding the numbers and then dividing it with the number of numbers in the collection. The arithmetic mean is used in almost all scientific disciplines for analysis.

Consider the collection of numbers - 5,7,8,12. The arithmetic mean is (5+7+8+12)/4 = 8.

There are multiple approaches to finding average of numbers in python. Here are some examples,

1. Find average of numbers using for loop in python,

numbers_str = input("Enter numbers separated by spaces: ")
numbers = [float(num) for num in numbers_str.split()]

total = 0;
for x in numbers:
    total = total + x
print("Average of ", numbers, " is ", total / len(numbers))

2. Find average of numbers using built-in functions in python,

numbers_str = input("Enter numbers separated by spaces: ")
numbers = [float(num) for num in numbers_str.split()]

print("Average of ", numbers, " is ", sum(numbers) / len(numbers))

3. Find average of numbers using module functions in python,

import statistics
numbers_str = input("Enter numbers separated by spaces: ")
numbers = [float(num) for num in numbers_str.split()]

print("Average of ", numbers, " is ", statistics.mean(numbers))

Here is the output of the above programs in console,

The factorial of a number n is defined as the product of all integers from 1 to the number n. For example, the factorial of number 5 is 1*2*3*4*5 = 120. Factorial of number n is represented as n!. For larger values of n, the factorial value is very high. The factorial of zero by convention is defined as 1.

In mathematics, the factorial operation is used in many areas such as mathematical analysis and algebra. For example, n! represents all the permutations of a set of n objects. The notation n! was introduced by french mathematician Christian Kramp in 1808.

1. The following python program uses a simple for loop for computing factorial,

number = int(input("Please enter a number: "))
if number == 0:
    print("0!=", 1)
else:
    factorial = 1
    for i in range(1,number+1): # start from 1
        factorial = factorial*i
    print(number,"!=",factorial)

2. The following python program uses the built-in math module for calculating factorial,

import math
number = int(input("Please enter a number: "))
print(number,"!=",math.factorial(number))

3. The following python program uses a recursive function for calculating factorial. This is possible since n! = n*(n-1)!.

def factorial(n):
    if n <= 1:
        return 1
    else:
        return n * factorial(n - 1)


number = int(input("Please enter a number: "))
print(number, "!=", factorial(number))

Here is the sample output from the above programs,

The following python program demonstrates how to perform AES 256 encryption and decryption using the pycrypto library. Please note that this example is written in Python 3.

First ensure that pycrypto library is installed on your system by running the following command,

In the following python 3 program, we use pycrypto classes for AES 256 encryption and decryption. The program asks the user for a password (passphrase) for encrypting the data. This passphrase is converted to a hash value before using it as the key for encryption. The following program encrypts a sample text and then prints both the encrypted message and decrypted message on the console.

# AES 256 encryption/decryption using pycrypto library

import base64
import hashlib
from Crypto.Cipher import AES
from Crypto import Random

BLOCK_SIZE = 16
pad = lambda s: s + (BLOCK_SIZE - len(s) % BLOCK_SIZE) * chr(BLOCK_SIZE - len(s) % BLOCK_SIZE)
unpad = lambda s: s[:-ord(s[len(s) - 1:])]

password = input("Enter encryption password: ")


def encrypt(raw, password):
    private_key = hashlib.sha256(password.encode("utf-8")).digest()
    raw = pad(raw)
    iv = Random.new().read(AES.block_size)
    cipher = AES.new(private_key, AES.MODE_CBC, iv)
    return base64.b64encode(iv + cipher.encrypt(raw))


def decrypt(enc, password):
    private_key = hashlib.sha256(password.encode("utf-8")).digest()
    enc = base64.b64decode(enc)
    iv = enc[:16]
    cipher = AES.new(private_key, AES.MODE_CBC, iv)
    return unpad(cipher.decrypt(enc[16:]))


# First let us encrypt secret message
encrypted = encrypt("This is a secret message", password)
print(encrypted)

# Let us decrypt using our original password
decrypted = decrypt(encrypted, password)
print(bytes.decode(decrypted))

Here is the above program in action,

Note that the above program uses SHA256 algorithm to generate the key from the passphrase. If you want high level of security, this should be replaced with password based key derivation function PBKDF2. The following example uses the PBKDF2 to generate the key,

# AES 256 encryption/decryption using pycrypto library

import base64
from Crypto.Cipher import AES
from Crypto import Random
from Crypto.Protocol.KDF import PBKDF2

BLOCK_SIZE = 16
pad = lambda s: s + (BLOCK_SIZE - len(s) % BLOCK_SIZE) * chr(BLOCK_SIZE - len(s) % BLOCK_SIZE)
unpad = lambda s: s[:-ord(s[len(s) - 1:])]

password = input("Enter encryption password: ")


def get_private_key(password):
    salt = b"this is a salt"
    kdf = PBKDF2(password, salt, 64, 1000)
    key = kdf[:32]
    return key


def encrypt(raw, password):
    private_key = get_private_key(password)
    raw = pad(raw)
    iv = Random.new().read(AES.block_size)
    cipher = AES.new(private_key, AES.MODE_CBC, iv)
    return base64.b64encode(iv + cipher.encrypt(raw))


def decrypt(enc, password):
    private_key = get_private_key(password)
    enc = base64.b64decode(enc)
    iv = enc[:16]
    cipher = AES.new(private_key, AES.MODE_CBC, iv)
    return unpad(cipher.decrypt(enc[16:]))


# First let us encrypt secret message
encrypted = encrypt("This is a secret message", password)
print(encrypted)

# Let us decrypt using our original password
decrypted = decrypt(encrypted, password)
print(bytes.decode(decrypted))

MD5 is a message digest algorithm used to create a unique fixed size value from variable input data. MD5 is commonly used to check whether a file is corrupted during transfer or not (in this case the hash value is known as checksum). Any change in the file will lead to a different MD5 hash value.

The following Python program computes MD5 hash of a given file. The computed 128 bit MD5 hash is converted to readable hexadecimal form.

# Python program to find MD5 hash value of a file
import hashlib

filename = input("Enter the file name: ")
with open(filename,"rb") as f:
    bytes = f.read() # read file as bytes
    readable_hash = hashlib.md5(bytes).hexdigest();
    print(readable_hash)

Note that the above program may fail for large input files since we read the entire file to memory before computing the MD5 hash. The following python program is an improved version capable of handling large files,

# Python program to find MD5 hash value of a file
import hashlib

filename = input("Enter the file name: ")
md5_hash = hashlib.md5()
with open(filename,"rb") as f:
    # Read and update hash in chunks of 4K
    for byte_block in iter(lambda: f.read(4096),b""):
        md5_hash.update(byte_block)
    print(md5_hash.hexdigest())

Here is the above program is action,

The following python program uses the bubble algorithm to sort a list of numbers. The program allows the user to input the list of numbers from the console. Please note that bubble sort is a very inefficient algorithm and hence is not recommended in production code with large data.

# Bubble sort in python
# Sorts numbers in ascending order
str_input = input("Please enter numbers separated by spaces: ")

# split the string into numbers & create a list of numbers
numbers = [int(x) for x in str_input.split()]

count = len(numbers)

for outer in range(count-1): # bubbles each number to the end
    for i in range(count-outer-1):
        if numbers[i] > numbers[i+1]:
            # swap numbers!
            numbers[i],numbers[i+1] = numbers[i+1],numbers[i]

print(numbers)

The above program asks the user to enter a list of numbers separated by spaces. This is split into individual numbers using the split() function and then converted to a list of numbers using the int() function and list comprehension.

The program then uses two nested loops to sort the numbers. The outer loop runs as many times as the numbers in the list. For each inner loop iteration, the largest number is bubbled to the right. Hence for each outer loop iteration, we get the next large number bubbled to the right.  Note that we are using a tuple assignment in python to swap two values in the list. There is no need for a temporary variable for swapping variable values.

Here is the sample output from the program,