python环境，编写SHA-1算法实现程序，运行SHA-1程序，演示SHA-1算法的计算过程。要求如下 (1) 编写程序实现任意消息的填充分组 (2) 编写程序实现消息扩展将每个分组中的16个32比特字扩展为80个32比特字 (3) 分别编写程序实现循环移位、32比特与(或、非)运算、模2^32加运算，建议将这些程序作为独立的程序，在整个运算中调用这些程序完成单向散列函数的计算。 (4) 用第二步的80个32比特字迭代修改初始的单向散列函数值，并输出最后的单向散列函数值。

以下是Python实现SHA-1算法的程序，包含了对消息的填充分组、消息扩展、循环移位、与(或、非)运算、模2^32加运算的实现。程序中包含了注释来解释每个步骤的作用。

import struct

# 定义SHA-1算法中使用的常量
h0 = 0x67452301
h1 = 0xEFCDAB89
h2 = 0x98BADCFE
h3 = 0x10325476
h4 = 0xC3D2E1F0

# 定义SHA-1算法中使用的函数
def sha1(message):
    # 将消息填充为512位的分组
    padded_message = pad_message(message)

    # 将每个分组的16个32比特字扩展为80个32比特字
    for i in range(0, len(padded_message), 64):
        block = padded_message[i:i+64]
        words = [0] * 80
        for j in range(16):
            words[j] = struct.unpack('>I', block[j*4:j*4+4])[0]
        for j in range(16, 80):
            words[j] = left_rotate(words[j-3] ^ words[j-8] ^ words[j-14] ^ words[j-16], 1)

        # 初始化单向散列函数的值
        a, b, c, d, e = h0, h1, h2, h3, h4

        # 迭代修改单向散列函数的值
        for j in range(80):
            if j < 20:
                f = (b & c) | ((~b) & d)
                k = 0x5A827999
            elif j < 40:
                f = b ^ c ^ d
                k = 0x6ED9EBA1
            elif j < 60:
                f = (b & c) | (b & d) | (c & d)
                k = 0x8F1BBCDC
            else:
                f = b ^ c ^ d
                k = 0xCA62C1D6
            temp = (left_rotate(a, 5) + f + e + k + words[j]) & 0xFFFFFFFF
            e = d
            d = c
            c = left_rotate(b, 30)
            b = a
            a = temp

        # 将迭代修改后的值与初始的单向散列函数值相加
        h0 = (h0 + a) & 0xFFFFFFFF
        h1 = (h1 + b) & 0xFFFFFFFF
        h2 = (h2 + c) & 0xFFFFFFFF
        h3 = (h3 + d) & 0xFFFFFFFF
        h4 = (h4 + e) & 0xFFFFFFFF

    # 输出最后的单向散列函数值
    return '%08x%08x%08x%08x%08x' % (h0, h1, h2, h3, h4)

# 将消息填充为512位的分组
def pad_message(message):
    # 计算消息的比特长度
    message_length = len(message) * 8

    # 添加比特'1'，直到消息长度为448模512
    message += b'\x80'
    while (len(message) * 8) % 512 != 448:
        message += b'\x00'

    # 添加消息长度的64位比特表示
    message += struct.pack('>Q', message_length)

    return message

# 将32比特的值循环左移n位
def left_rotate(n, b):
    return ((n << b) | (n >> (32 - b))) & 0xFFFFFFFF

# 32比特与(或、非)运算
def ch(x, y, z):
    return (x & y) ^ (~x & z)

# 32比特与(或、非)运算
def maj(x, y, z):
    return (x & y) ^ (x & z) ^ (y & z)

# 模2^32加运算
def sum32(x, y):
    return (x + y) & 0xFFFFFFFF

下面是一个演示SHA-1算法计算过程的示例程序，它将输入的消息作为参数传递给SHA-1算法函数，并输出最终的单向散列函数值。

message = b'This is a test message'
hash_value = sha1(message)
print('SHA-1 hash of', message, 'is', hash_value)