python3 base64模块代码分析

 #! /usr/bin/env python3

 """Base16, Base32, Base64 (RFC 3548), Base85 and Ascii85 data encodings"""

 # Modified 04-Oct-1995 by Jack Jansen to use binascii module
 # Modified 30-Dec-2003 by Barry Warsaw to add full RFC 3548 support
 # Modified 22-May-2007 by Guido van Rossum to use bytes everywhere

 import re
 import struct
 import binascii

 __all__ = [
     # Legacy interface exports traditional RFC 1521 Base64 encodings
     'encode', 'decode', 'encodebytes', 'decodebytes',
     # Generalized interface for other encodings
     'b64encode', 'b64decode', 'b32encode', 'b32decode',
     'b16encode', 'b16decode',
     # Base85 and Ascii85 encodings
     'b85encode', 'b85decode', 'a85encode', 'a85decode',
     # Standard Base64 encoding
     'standard_b64encode', 'standard_b64decode',
     # Some common Base64 alternatives.  As referenced by RFC 3458, see thread
     # starting at:
     #
     # http://zgp.org/pipermail/p2p-hackers/2001-September/000316.html
     'urlsafe_b64encode', 'urlsafe_b64decode',
     ]

 bytes_types = (bytes, bytearray)  # Types acceptable as binary data

 def _bytes_from_decode_data(s):
     '''
     返回字节包，否则抛出异常
     '''
     if isinstance(s, str):
         try:
             return s.encode('ascii')
         except UnicodeEncodeError:
             raise ValueError('string argument should contain only ASCII characters')
     if isinstance(s, bytes_types):

         #s是否是bytes或者bytearray中的某种类型。isinstance(s,(type1,type2,...))

         return s
     try:
         return memoryview(s).tobytes()

     #memoryview()返回内存指针，s必须是bytes或bytearray类型
     #memoryview(b'abc')     ==> <memory at 0x0000000003723368>
     #memoryview(b'abc').tobytes()   ==> b'abc'
     #memoryview(b'abc')[0]  ==> b'a'

     except TypeError:
         raise TypeError("argument should be a bytes-like object or ASCII "
                         "string, not %r" % s.__class__.__name__) from None

 # Base64 encoding/decoding uses binascii

 def b64encode(s, altchars=None):
     """Encode a byte string using Base64.

     s is the byte string to encode.  Optional altchars must be a byte
     string of length 2 which specifies an alternative alphabet for the
     '+' and '/' characters.  This allows an application to
     e.g. generate url or filesystem safe Base64 strings.

     The encoded byte string is returned.
     """
     # Strip off the trailing newline
     encoded = binascii.b2a_base64(s)[:-1]

     #将二进制字节包s转换成经过base64编码的ascii字节包

     if altchars is not None:

         #如果有altchars选项，且altchars长度为2，则用其替换'+'和'/'

         assert len(altchars) == 2, repr(altchars)
         return encoded.translate(bytes.maketrans(b'+/', altchars))

     #在已经是base64编码的encoded中替换b'+/'为altchars对应的字符
     #bytes.maketrans(frm,to)返回一个从frm到to的映射表
     #encoded.translate()采用maketrans返回的映射表将encoded转换

     return encoded

 def b64decode(s, altchars=None, validate=False):
     """Decode a Base64 encoded byte string.

     s is the byte string to decode.  Optional altchars must be a
     string of length 2 which specifies the alternative alphabet used
     instead of the '+' and '/' characters.

     The decoded string is returned.  A binascii.Error is raised if s is
     incorrectly padded.

     If validate is False (the default), non-base64-alphabet characters are
     discarded prior to the padding check.  If validate is True,
     non-base64-alphabet characters in the input result in a binascii.Error.
     """
     s = _bytes_from_decode_data(s)
     if altchars is not None:
         altchars = _bytes_from_decode_data(altchars)
         assert len(altchars) == 2, repr(altchars)
         s = s.translate(bytes.maketrans(altchars, b'+/'))
     if validate and not re.match(b'^[A-Za-z0-9+/]*={0,2}$', s):

         #base64编码最后补位的等号个数只能是0,1,2

         raise binascii.Error('Non-base64 digit found')
     return binascii.a2b_base64(s)

 #将ascii形式的base64解码

 def standard_b64encode(s):
     """Encode a byte string using the standard Base64 alphabet.

     s is the byte string to encode.  The encoded byte string is returned.
     """
     return b64encode(s)

 def standard_b64decode(s):
     """Decode a byte string encoded with the standard Base64 alphabet.

     s is the byte string to decode.  The decoded byte string is
     returned.  binascii.Error is raised if the input is incorrectly
     padded or if there are non-alphabet characters present in the
     input.
     """
     return b64decode(s)

 _urlsafe_encode_translation = bytes.maketrans(b'+/', b'-_')
 _urlsafe_decode_translation = bytes.maketrans(b'-_', b'+/')

 #url的base64编码中将'+/'替换成了'-_'

 def urlsafe_b64encode(s):
     """Encode a byte string using a url-safe Base64 alphabet.

     s is the byte string to encode.  The encoded byte string is
     returned.  The alphabet uses '-' instead of '+' and '_' instead of
     '/'.
     """
     return b64encode(s).translate(_urlsafe_encode_translation)

 def urlsafe_b64decode(s):
     """Decode a byte string encoded with the standard Base64 alphabet.

     s is the byte string to decode.  The decoded byte string is
     returned.  binascii.Error is raised if the input is incorrectly
     padded or if there are non-alphabet characters present in the
     input.

     The alphabet uses '-' instead of '+' and '_' instead of '/'.
     """
     s = _bytes_from_decode_data(s)
     s = s.translate(_urlsafe_decode_translation)
     return b64decode(s)

 # Base32 encoding/decoding must be done in Python
 _b32alphabet = b'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'

 #base32用的32个字符是'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'
 _b32tab2 = None
 _b32rev = None

 def b32encode(s):
     """Encode a byte string using Base32.

     s is the byte string to encode.  The encoded byte string is returned.
     """
     global _b32tab2
     # Delay the initialization of the table to not waste memory
     # if the function is never called
     if _b32tab2 is None:
         b32tab = [bytes((i,)) for i in _b32alphabet]

         #bytes(iterable_of_ints) -> bytes
         #(i,)是一个可迭代的数字元组，如(61,) (62,)……也可以是bytes([i,])
         #bytes((66,))  ==> b'B'
         #bytes((66,67)) ==> b'BC'
         #[i for i in _b32alphabet]返回一个int类型的列表

         _b32tab2 = [a + b for a in b32tab for b in b32tab]

         #_b32tab2 = [b'AA',b'AB',b'AC',.......,b'76',b'77']
         #len(_b32tab2) ==> 1024,每10bit截取一次，每次都对应着1024中的一组

         b32tab = None

     if not isinstance(s, bytes_types):
         s = memoryview(s).tobytes()
     leftover = len(s) % 5
     # Pad the last quantum with zero bits if necessary
     if leftover:
         s = s + bytes(5 - leftover)  # Don't use += !

         #填充5-leftover个字节的0

     encoded = bytearray()
     from_bytes = int.from_bytes
     b32tab2 = _b32tab2
     for i in range(0, len(s), 5):
         c = from_bytes(s[i: i + 5], 'big')

         #int.from_bytes(b'\x00\x10', byteorder='big') ==> 16
         #int.from_bytes(b'\x00\x10', byteorder='little') ==> 4096

         encoded += (b32tab2[c >> 30] +           # bits 1 - 10
                     b32tab2[(c >> 20) & 0x3ff] + # bits 11 - 20
                     b32tab2[(c >> 10) & 0x3ff] + # bits 21 - 30
                     b32tab2[c & 0x3ff]           # bits 31 - 40
                    )
     # Adjust for any leftover partial quanta
     if leftover == 1:
         encoded[-6:] = b'======'
     elif leftover == 2:
         encoded[-4:] = b'===='
     elif leftover == 3:
         encoded[-3:] = b'==='
     elif leftover == 4:
         encoded[-1:] = b'='
     return bytes(encoded)

 '''
 以b'abc'编码为例，解释编码后补齐的=个数:
     a      b    c      x      x

    8    + 2 6  +4 4   +6 2    +8
    -------- ----- ------ -------
       AB     CD    4  +1 5 + 2 + 8
                    -----
                      E      ===
 base32,5bit一个编码字符
 '''

 def b32decode(s, casefold=False, map01=None):
     """Decode a Base32 encoded byte string.

     s is the byte string to decode.  Optional casefold is a flag
     specifying whether a lowercase alphabet is acceptable as input.
     For security purposes, the default is False.

     RFC 3548 allows for optional mapping of the digit 0 (zero) to the
     letter O (oh), and for optional mapping of the digit 1 (one) to
     either the letter I (eye) or letter L (el).  The optional argument
     map01 when not None, specifies which letter the digit 1 should be
     mapped to (when map01 is not None, the digit 0 is always mapped to
     the letter O).  For security purposes the default is None, so that
     0 and 1 are not allowed in the input.

     The decoded byte string is returned.  binascii.Error is raised if
     the input is incorrectly padded or if there are non-alphabet
     characters present in the input.
     """
     global _b32rev
     # Delay the initialization of the table to not waste memory
     # if the function is never called
     if _b32rev is None:
         _b32rev = {v: k for k, v in enumerate(_b32alphabet)}

         #{65: 0, 66: 1, 67: 2, 68: 3, 69: 4, 70: 5, 71: 6, 72: 7, 73: 8,
         #74: 9, 75: 10, 76: 11, 77: 12, 78: 13, 79: 14, 80: 15, 81: 16,
         #82: 17, 83: 18, 84: 19, 85: 20, 86: 21, 87: 22, 88: 23, 89: 24,
         #90: 25, 50: 26, 51: 27, 52: 28, 53: 29, 54: 30, 55: 31}

     s = _bytes_from_decode_data(s)
     if len(s) % 8:
         raise binascii.Error('Incorrect padding')
     # Handle section 2.4 zero and one mapping.  The flag map01 will be either
     # False, or the character to map the digit 1 (one) to.  It should be
     # either L (el) or I (eye).
     if map01 is not None:
         map01 = _bytes_from_decode_data(map01)
         assert len(map01) == 1, repr(map01)
         s = s.translate(bytes.maketrans(b'', b'O' + map01))
     if casefold:
         s = s.upper()
     # Strip off pad characters from the right.  We need to count the pad
     # characters because this will tell us how many null bytes to remove from
     # the end of the decoded string.
     l = len(s)
     s = s.rstrip(b'=')
     padchars = l - len(s)       #填充了几个等号
     # Now decode the full quanta
     decoded = bytearray()
     b32rev = _b32rev
     for i in range(0, len(s), 8):
         quanta = s[i: i + 8]
         acc = 0
         try:
             for c in quanta:
                 acc = (acc << 5) + b32rev[c]
         except KeyError:
             raise binascii.Error('Non-base32 digit found') from None
         decoded += acc.to_bytes(5, 'big')
     # Process the last, partial quanta
     if padchars:
         acc <<= 5 * padchars   #每一个padchars相当于占了5bit
         last = acc.to_bytes(5, 'big') #计算包含补充等号的后五位
         if padchars == 1: #填充了一个字符位
             decoded[-5:] = last[:-1]
         elif padchars == 3: #填充了两个字符位
             decoded[-5:] = last[:-2]
         elif padchars == 4: #填充了三个字符位
             decoded[-5:] = last[:-3]
         elif padchars == 6: #填充了四个字符位
             decoded[-5:] = last[:-4]
         else:
             raise binascii.Error('Incorrect padding')
     return bytes(decoded)