Python實現(xiàn)加解密,編碼解碼和進制轉(zhuǎn)換(最全版)
更新時間：2023年01月09日 08:44:33 作者：小木_.
這篇文章主要為大家詳細介紹了Python實現(xiàn)加解密、編碼解碼、進制轉(zhuǎn)換、字符串轉(zhuǎn)換的最全版操作方法，文中的示例代碼講解詳細，大家可以收藏一下
請先安裝這幾個模塊
# Python 3.11.0 import hashlib import binascii import google_crc32c import zlib import base64 import urllib.parse import opencc import time from Crypto.Cipher import AES # 安裝方法如下 # 打開cmd 輸入如下代碼回車即可 pip install hashlib pip install binascii pip install google_crc32c pip install zlib pip install base64 pip install urllib.parse pip install opencc # 安裝 Crypto.Cipher pip install pycryptodome
一、加密(不含解密)
1、MD4
import hashlib
def md4_encrypt(string):
md4 = hashlib.new('md4')
md4.update(string.encode('utf-8'))
return md4.hexdigest()
# 輸入
print(md4_encrypt("你好"))
# 輸出：a7f1196539fd1f85f754ffd185b16e6e
2、MD5
import hashlib
def md5_encrypt(string):
md5 = hashlib.md5()
md5.update(string.encode('utf-8'))
return md5.hexdigest()
# 輸入
print(md5_encrypt("你好"))
# 輸出：7eca689f0d3389d9dea66ae112e5cfd7
3、blake2b
import hashlib
def blake2b_encrypt(string):
blake2b = hashlib.blake2b()
blake2b.update(string.encode('utf-8'))
return blake2b.hexdigest()
# 輸入
print(blake2b_encrypt("你好"))
# 輸出：8eadb63a9f823c4e8eac400247995c69ab714dd54cc33bbf0583e269e3aa9077ad8c0069ffb2fec634a1dd913196c0e459f987a1e5d3c9997e9fd556b38604a4
4、blake2s
import hashlib
def blake2s_encrypt(string):
blake2s = hashlib.blake2s()
blake2s.update(string.encode('utf-8'))
return blake2s.hexdigest()
# 輸入
print(blake2s_encrypt("你好"))
# 輸出：b834cce099cfa370b999ebfa3bb8a6a87fa09b45a1a83d038d8957cbb88c9896
5、SHA1
import hashlib
def sha1_encrypt(string):
sha1 = hashlib.sha1()
sha1.update(string.encode('utf-8'))
return sha1.hexdigest()
# 輸入
print(sha1_encrypt("你好"))
# 輸出：440ee0853ad1e99f962b63e459ef992d7c211722
6、SHA224
import hashlib
def sha224_encrypt(string):
sha224 = hashlib.sha224()
sha224.update(string.encode('utf-8'))
return sha224.hexdigest()
# 輸入
print(sha224_encrypt("你好"))
# 輸出：e91f006ed4e0882de2f6a3c96ec228a6a5c715f356d00091bce842b5
7、SHA256
import hashlib
def sha256_encrypt(string):
sha256 = hashlib.sha256()
sha256.update(string.encode('utf-8'))
return sha256.hexdigest()
# 輸入
print(sha256_encrypt("你好"))
# 輸出：670d9743542cae3ea7ebe36af56bd53648b0a1126162e78d81a32934a711302e
8、SHA384
import hashlib
def sha384_encrypt(string):
sha384 = hashlib.sha384()
sha384.update(string.encode('utf-8'))
return sha384.hexdigest()
# 輸入
print(sha384_encrypt("你好"))
# 輸出：05f076c7d180e91d80a56d70b226fca01e2353554c315ac1e8caaaeca2ce0dc0d9d84e206a2bf1143a0ae1b9be9bcfa8
9、SHA512
import hashlib
def sha512_encrypt(string):
sha512 = hashlib.sha512()
sha512.update(string.encode('utf-8'))
return sha512.hexdigest()
# 輸入
print(sha512_encrypt("你好"))
# 輸出：5232181bc0d9888f5c9746e410b4740eb461706ba5dacfbc93587cecfc8d068bac7737e92870d6745b11a25e9cd78b55f4ffc706f73cfcae5345f1b53fb8f6b5
10、SHA3_224
import hashlib
def sha3_224_encrypt(string):
sha3_224 = hashlib.sha3_224()
sha3_224.update(string.encode('utf-8'))
return sha3_224.hexdigest()
# 輸入
print(sha3_224_encrypt("你好"))
# 輸出：d6e2200b43a6997075692b6dde5ca9f91cae1d15f72546d3c9a9d8c4
11、SHA3_256
import hashlib
def sha3_256_encrypt(string):
sha3_256 = hashlib.sha3_256()
sha3_256.update(string.encode('utf-8'))
return sha3_256.hexdigest()
# 輸入
print(sha3_224_encrypt("你好"))
# 輸出：0100e69a7157f3a814a3cf6895f4fccd6b610b9947224b2aaa7aa11dd0dca833
12、SHA3_384
import hashlib
def sha3_384_encrypt(string):
sha3_384 = hashlib.sha3_384()
sha3_384.update(string.encode('utf-8'))
return sha3_384.hexdigest()
# 輸入
print(sha3_384_encrypt("你好"))
# 輸出：bdc0b2e622a1d79abae4cabbf86bd88192dead3b90c8332ac4bac08e9a2c06d5c685f46101ac0c14980849f39a7b0ebf
13、SHA3_512
import hashlib
def sha3_512_encrypt(string):
sha3_512 = hashlib.sha3_512()
sha3_512.update(string.encode('utf-8'))
return sha3_512.hexdigest()
# 輸入
print(sha3_512_encrypt("你好"))
# 輸出：d673e4b36755b938359fa394cf920b4430a34f447ea5cb10485d9d46a7d6682eef6d7459b4dac9019d908e08a1e7aaab3accde4f59e862dbb99f906d85e5c66d
14、shake_128
import hashlib
def shake_128_encrypt(data):
data = data.encode('utf-8')
shake_128 = hashlib.shake_128()
shake_128.update(data)
return shake_128.hexdigest(32)
# 輸入
print(shake_128_encrypt("你好"))
# 輸出：2c8206e6e29e0e3c9d64e9455629cd354548a15761d3bafcb941769ed4649538
15、shake_256
import hashlib
def shake_256_encrypt(data):
data = data.encode('utf-8')
shake_256 = hashlib.shake_256()
shake_256.update(data)
return shake_256.hexdigest(32)
# 輸入
print(shake_256_encrypt("你好"))
# 輸出：d13a972c4c06e0cbb67af0af4b1a92d296b709e36cccbeed30db6c9d2853cd1c
16、crc32 十進制
import binascii
def crc32_10(data):
return binascii.crc32(data.encode()) & 0xffffffff
# 輸入
print(crc32_10("你好"))
# 輸出：1352841281
17、crc32 十六進制
import binascii
def crc32_16(data):
return hex(binascii.crc32(data.encode()) & 0xffffffff)
# 輸入
print(crc32_16("你好"))
# 輸出：0x50a2b841
18、CRC32C十進制
import google_crc32c
def crc32c_10(data):
return google_crc32c.value(data.encode())
# 輸入
print(crc32c_10("你好"))
# 輸出：1383944972
19、CRC32C十六進制
import google_crc32c
def crc32c_16(data):
return hex(google_crc32c.value(data.encode()))
# 輸入
print(crc32c_16("你好"))
# 輸出：0x527d530c
20、Adler32十進制
import zlib
def adler32_10(data):
return zlib.adler32(data.encode()) & 0xffffffff
# 輸入
print(adler32_10("你好"))
# 輸出：272958601
21、Adler32十六進制
import zlib
def adler32_16(data):
return hex(zlib.adler32(data.encode()) & 0xffffffff)
# 輸入
print(adler32_16("你好"))
# 輸出：0x10450489
二、加密&解密
1、IDEA 加密解密
# IDEA【加密算法】
def IDEA_encrypt(string, key): # string要加密的字符串 key只能為數(shù)字,5位數(shù)內(nèi)
result = ''
for i in range(len(string)):
result += chr(ord(string[i]) + int(key))
return result
# 輸入
print(IDEA_encrypt("你好",443322))
# 輸出：????
# IDEA【解密算法】
def IDEA_decrypt(string, key): # string要加密的字符串 key只能為數(shù)字,5位數(shù)內(nèi)
result = ''
for i in range(len(string)):
result += chr(ord(string[i]) - int(key))
return result
# 輸入
print(IDEA_decrypt("????",443322))
# 輸出：你好
2、ASCLL 加密解密
# ASCLL【加密】
def decrypt_ASCLL(string):
result = ""
for char in string:
result += chr(ord(char) + 1000)
return result
# 輸入
print(decrypt_ASCLL('你好'))
# 輸出：午嵥
# ASCLL【解密】
def encrypt_ASCLL(string):
result = ""
for char in string:
result += chr(ord(char) - 1000)
return result
# 輸入
print(encrypt_ASCLL('午嵥'))
# 輸出：你好
3、AES_ECB 加密解密
# AES 【ECB加密】
# AES 【加密】 加密模式(不可改)：ECB key(默認)：0000000000000000 填充模式(默認)：NoPadding 子集編碼(默認)：UTF-8 字節(jié)(不可改)：128字節(jié)
from Crypto.Cipher import AES
import base64
def AES_ECB_encode(data,key=b'0000000000000000',paddingMode='NoPadding',characterSet='UTF-8'):
'''
# data：加解密內(nèi)容【解密】
# key：密鑰，長度為16字節(jié)或32字節(jié)
# paddingMode：填充模式，默認為NoPadding 可選【NoPadding，ZeroPadding，PKCS5Padding，PKCS7Padding】
# characterSet：編碼，默認為UTF-8 可選【UTF-8，UTF-16_LE，GBK】
'''
# 檢測密鑰的長度是否是16或32字節(jié)長度
if len(key) in [16,32]:
data = data.encode(characterSet)
AESS = AES.new(key, AES.MODE_ECB)
enData = ''
if paddingMode == 'NoPadding':
if len(data) % 16 == 0:
enData = AESS.encrypt(data) # AES加密
else:
if len(data) % 16 != 0:
data += b'\x00'
while len(data) % 16 != 0:
data += b'\x00'
data = data
enData = AESS.encrypt(data) # AES加密
if paddingMode == 'ZeroPadding':
if len(data) % 16 != 0:
data += b'\x00'
while len(data) % 16 != 0:
data += b'\x00'
data = data
enData = AESS.encrypt(data) # AES加密
if paddingMode in ['PKCS5Padding','PKCS7Padding']:
needSize = 16 - len(data) % 16
if needSize == 0:
needSize = 16
data = data + needSize.to_bytes(1, 'little') * needSize
enData = AESS.encrypt(data) # AES加密
return base64.b64encode(enData).decode()
else:
return '密鑰或iv字節(jié)長度錯誤?。。?
# 輸入
print(AES_ECB_encode('你好 Abc',key=b'1234567890123456',paddingMode='PKCS5Padding'))
# 輸出：3ZJEr/p5lexy81r+IRGGoQ==# AES 【ECB解密】
# AES 【解密】 加密模式(不可改)：ECB key(默認)：0000000000000000 填充模式(默認)：NoPadding 子集編碼(默認)：UTF-8 字節(jié)(不可改)：128字節(jié)
from Crypto.Cipher import AES
import base64
def AES_ECB_decode(data,key=b'0000000000000000',paddingMode='NoPadding',characterSet='UTF-8'):
'''
# data：加解密內(nèi)容【解密】
# key：密鑰，長度為16字節(jié)或32字節(jié)
# paddingMode：填充模式，默認為NoPadding 可選【NoPadding，ZeroPadding，PKCS5Padding，PKCS7Padding】
# characterSet：編碼，默認為UTF-8 可選【UTF-8，UTF-16_LE，GBK】
'''
if len(key) in [16, 32]:
data = base64.b64decode(data.encode(characterSet))
data = AES.new(key, AES.MODE_ECB).decrypt(data)
if paddingMode in ['NoPadding','ZeroPadding']:
data = data[:-1]
while len(data) % 16 != 0:
data = data.rstrip(b'\x00')
if data[-1] != b"\x00":
break
if paddingMode in ['PKCS5Padding','PKCS7Padding']:
paddingSize = data[-1]
data = data.rstrip(paddingSize.to_bytes(1, 'little'))
return data.decode(characterSet)
else:
return '密鑰或iv字節(jié)長度錯誤！??！'
# 輸入
print(AES_ECB_decode('3ZJEr/p5lexy81r+IRGGoQ==',key=b'1234567890123456',paddingMode='PKCS5Padding'))
# 輸出：你好 Abc4、AES_CBC 加密解密
# AES 【CBC加密】
# AES 【加密】 加密模式(不可改)：CBC key/iv(默認)：0000000000000000 填充模式(默認)：NoPadding 子集編碼(默認)：UTF-8 字節(jié)(不可改)：128字節(jié)
from Crypto.Cipher import AES
import base64
def AES_CBC_encode(data,key=b'0000000000000000',iv=b'0000000000000000',paddingMode='NoPadding',characterSet='UTF-8'):
'''
# data：加解密內(nèi)容【解密】
# key：密鑰，長度為16字節(jié)或32字節(jié)
# iv：偏移量，長度為16字節(jié)
# paddingMode：填充模式，默認為NoPadding 可選【NoPadding，ZeroPadding，PKCS5Padding，PKCS7Padding】
# characterSet：編碼，默認為UTF-8 可選【UTF-8，UTF-16_LE，GBK】
'''
# 檢測密鑰的長度是否是16或32字節(jié)長度，iv偏移量的字節(jié)長度是否是16字節(jié)
if (len(key) in [16,32]) and (len(iv) in [16]) == True:
data = data.encode(characterSet)
AESS = AES.new(key, AES.MODE_CBC, iv)
enData = ''
if paddingMode == 'NoPadding':
if len(data) % 16 == 0:
enData = AESS.encrypt(data) # AES加密
else:
if len(data) % 16 != 0:
data += b'\x00'
while len(data) % 16 != 0:
data += b'\x00'
data = data
enData = AESS.encrypt(data) # AES加密
if paddingMode == 'ZeroPadding':
if len(data) % 16 != 0:
data += b'\x00'
while len(data) % 16 != 0:
data += b'\x00'
data = data
enData = AESS.encrypt(data) # AES加密
if paddingMode in ['PKCS5Padding','PKCS7Padding']:
needSize = 16 - len(data) % 16
if needSize == 0:
needSize = 16
data = data + needSize.to_bytes(1, 'little') * needSize
enData = AESS.encrypt(data) # AES加密
return base64.b64encode(enData).decode()
else:
return '密鑰或iv字節(jié)長度錯誤！??！'
# 輸入
print(AES_CBC_encode('你好 Abc',key=b'1234567890123456',paddingMode='PKCS5Padding'))
# 輸出：VzrFG9/TsFTW+yup4/tr4g==# AES 【CBC解密】
# AES 【解密】 加密模式(不可改)：CBC key/iv(默認)：0000000000000000 填充模式(默認)：NoPadding 子集編碼(默認)：UTF-8 字節(jié)(不可改)：128字節(jié)
from Crypto.Cipher import AES
import base64
def AES_CBC_decode(data,key=b'0000000000000000',iv=b'0000000000000000',paddingMode='NoPadding',characterSet='UTF-8'):
'''
# data：加解密內(nèi)容【解密】
# key：密鑰，長度為16字節(jié)或32字節(jié)
# iv：偏移量，長度為16字節(jié)
# paddingMode：填充模式，默認為NoPadding 可選【NoPadding，ZeroPadding，PKCS5Padding，PKCS7Padding】
# characterSet：編碼，默認為UTF-8 可選【UTF-8，UTF-16_LE，GBK】
'''
if (len(key) in [16, 32]) and (len(iv) in [16]) == True:
data = base64.b64decode(data.encode(characterSet))
data = AES.new(key, AES.MODE_CBC, iv).decrypt(data)
if paddingMode in ['NoPadding','ZeroPadding']:
data = data[:-1]
while len(data) % 16 != 0:
data = data.rstrip(b'\x00')
if data[-1] != b"\x00":
break
if paddingMode in ['PKCS5Padding','PKCS7Padding']:
paddingSize = data[-1]
data = data.rstrip(paddingSize.to_bytes(1, 'little'))
return data.decode(characterSet)
else:
return '密鑰或iv字節(jié)長度錯誤！??！'
# 輸入
print(AES_CBC_decode('VzrFG9/TsFTW+yup4/tr4g==',key=b'1234567890123456',paddingMode='PKCS5Padding'))
# 輸出：你好 Abc5、AES_CFB 加密解密
# AES 【CFB加密】
# AES 【加密】 加密模式(不可改)：CFB key/iv(默認)：0000000000000000 塊大小(bits)(默認)：16 填充模式(默認)：NoPadding 子集編碼(默認)：UTF-8 字節(jié)(不可改)：128字節(jié)
from Crypto.Cipher import AES
import base64
def AES_CFB_encode(data,key=b'0000000000000000',iv=b'0000000000000000',segment_size=16,paddingMode='NoPadding',characterSet='UTF-8'):
'''
# data：加解密內(nèi)容【解密】
# key：密鑰，長度為16字節(jié)或32字節(jié)
# iv：偏移量，長度為16字節(jié)
# segment_size：塊大小(bits) 默認為 8 最小值為 8 最大值為128 只能是8的倍數(shù)，如：8，16，24，32，40，48，56，64...
# paddingMode：填充模式，默認為NoPadding 可選【NoPadding，ZeroPadding，PKCS5Padding，PKCS7Padding】
# characterSet：編碼，默認為UTF-8 可選【UTF-8，UTF-16_LE，GBK】
'''
# 檢測密鑰的長度是否是16或32字節(jié)長度
if (len(key) in [16,32]) and (len(iv) in [16]) == True:
data = data.encode(characterSet)
AESS = AES.new(key, AES.MODE_CFB,iv,segment_size=segment_size)
enData = ''
if paddingMode == 'NoPadding':
if len(data) % 2 == 0:
enData = AESS.encrypt(data) # AES加密
else:
if len(data) % 2 != 0:
data += b'\x00'
while len(data) % 2 != 0:
data += b'\x00'
data = data
enData = AESS.encrypt(data) # AES加密
if paddingMode == 'ZeroPadding':
if len(data) % 16 != 0:
data += b'\x00'
while len(data) % 16 != 0:
data += b'\x00'
data = data
enData = AESS.encrypt(data) # AES加密
if paddingMode in ['PKCS5Padding','PKCS7Padding']:
needSize = 16 - len(data) % 16
if needSize == 0:
needSize = 16
data = data + needSize.to_bytes(1, 'little') * needSize
enData = AESS.encrypt(data) # AES加密
return base64.b64encode(enData).decode()
else:
return '密鑰或iv字節(jié)長度錯誤?。?！'
# 輸入
print(AES_CFB_encode('你好 Abc',key=b'1234567890123456',iv=b'1111111111111111',paddingMode='NoPadding'))
# 輸出：QiLUCMq9uwxjUw==# AES 【CFB解密】
# AES 【解密】 加密模式(不可改)：CFB key/iv(默認)：0000000000000000 塊大小(bits)(默認)：16 填充模式(默認)：NoPadding 子集編碼(默認)：UTF-8 字節(jié)(不可改)：128字節(jié)
from Crypto.Cipher import AES
import base64
def AES_CFB_decode(data,key=b'0000000000000000',iv=b'0000000000000000',segment_size=16,paddingMode='NoPadding',characterSet='UTF-8'):
'''
# data：加解密內(nèi)容【解密】
# key：密鑰，長度為16字節(jié)或32字節(jié)
# iv：偏移量，長度為16字節(jié)
# segment_size：塊大小(bits) 默認為 8 最小值為 8 最大值為128 只能是8的倍數(shù)，如：8，16，24，32，40，48，56，64...
# paddingMode：填充模式，默認為NoPadding 可選【NoPadding，ZeroPadding，PKCS5Padding，PKCS7Padding】
# characterSet：編碼，默認為UTF-8 可選【UTF-8，UTF-16_LE，GBK】
'''
if (len(key) in [16,32]) and (len(iv) in [16]) == True:
data = base64.b64decode(data.encode(characterSet))
data = AES.new(key, AES.MODE_CFB,iv,segment_size=segment_size).decrypt(data)
if paddingMode in ['NoPadding']:
while len(data) % 2 != 0:
data = data.rstrip(b'\x00')
if data != b"\x00":
break
if paddingMode in ['ZeroPadding']:
data = data[:-1]
while len(data) % 16 != 0:
data = data.rstrip(b'\x00')
if data[-1] != b"\x00":
break
if paddingMode in ['PKCS5Padding','PKCS7Padding']:
paddingSize = data[-1]
data = data.rstrip(paddingSize.to_bytes(1, 'little'))
return data.decode(characterSet)
else:
return '密鑰或iv字節(jié)長度錯誤?。?！'
# 輸入
print(AES_CFB_decode('QiLUCMq9uwxjUw==',key=b'1234567890123456',iv=b'1111111111111111',paddingMode='NoPadding'))
# 輸出：你好 Abc6、DES_CBC 加密解密
# DES 【CBC加密】
# DES 【加密】 加密模式(不可改)：CBC key/iv(默認)：00000000 塊大小(bits)(默認)：16 填充模式(默認)：NoPadding 子集編碼(默認)：UTF-8
from Crypto.Cipher import DES
import base64
def DES_CBC_encode(data,key=b'00000000',iv=b'00000000',paddingMode='NoPadding',characterSet='UTF-8'):
'''
# data：加解密內(nèi)容【解密】
# key：密鑰，長度為8字節(jié)
# iv：偏移量，長度為8字節(jié)
# paddingMode：填充模式，默認為NoPadding 可選【NoPadding，ZeroPadding，PKCS5Padding，PKCS7Padding】
# characterSet：編碼，默認為UTF-8 可選【UTF-8，UTF-16_LE，GBK】
'''
if [(len(key)),len(iv)] == [8,8]:
DESS = DES.new(key, DES.MODE_CBC,iv)
data = data.encode(characterSet)
enData = ''
if paddingMode in ['NoPadding','ZeroPadding']:
if len(data) % 16 != 0:
data += b'\x00'
while len(data) % 16 != 0:
data += b'\x00'
data = data
enData = DESS.encrypt(data) # DES加密
if paddingMode in ['PKCS5Padding','PKCS7Padding']:
needSize = 16 - len(data) % 16
if needSize == 0:
needSize = 16
data = data + needSize.to_bytes(1, 'little') * needSize
enData = DESS.encrypt(data) # DES加密
return base64.b64encode(enData).decode()
else:
return '密鑰或iv字節(jié)長度錯誤?。?！'
# 輸入
print(DES_CBC_encode('你好 Abc',key=b'12345678',iv=b'88888888',paddingMode='ZeroPadding'))
# 輸出：4jaMYjQEe5FW1JJyDhCliQ==# DES 【CBC解密】
# DES 【解密】 加密模式(不可改)：CBC key/iv(默認)：00000000 塊大小(bits)(默認)：16 填充模式(默認)：NoPadding 子集編碼(默認)：UTF-8
from Crypto.Cipher import DES
import base64
def DES_CBC_decode(data,key=b'00000000',iv=b'00000000',paddingMode='NoPadding',characterSet='UTF-8'):
'''
# data：加解密內(nèi)容【解密】
# key：密鑰，長度為8字節(jié)
# iv：偏移量，長度為8字節(jié)
# paddingMode：填充模式，默認為NoPadding 可選【NoPadding，ZeroPadding，PKCS5Padding，PKCS7Padding】
# characterSet：編碼，默認為UTF-8 可選【UTF-8，UTF-16_LE，GBK】
'''
if [(len(key)),len(iv)] == [8,8]:
data = base64.b64decode(data.encode(characterSet))
data = DES.new(key, DES.MODE_CBC, iv).decrypt(data)
if paddingMode in ['NoPadding','ZeroPadding']:
data = data[:-1]
while len(data) % 16 != 0:
data = data.rstrip(b'\x00')
if data[-1] != b"\x00":
break
if paddingMode in ['PKCS5Padding', 'PKCS7Padding']:
paddingSize = data[-1]
data = data.rstrip(paddingSize.to_bytes(1, 'little'))
return data.decode(characterSet)
else:
return '密鑰或iv字節(jié)長度錯誤?。?！'
# 輸入
print(DES_CBC_decode('4jaMYjQEe5FW1JJyDhCliQ==',key=b'12345678',iv=b'88888888',paddingMode='ZeroPadding'))
# 輸出：你好 Abc三、編碼&解碼
1、base64 編碼解碼（文字）
# base64 【編碼】
import base64
def base64_encode(str):
return base64.b64encode(str.encode('utf-8')).decode('utf-8')
# 輸入
print(base64_encode("你好"))
# 輸出：5L2g5aW9
# base64 【解碼】
import base64
def base64_decode(str):
return base64.b64decode(str).decode('utf-8')
# 輸入
print(base64_decode("5L2g5aW9"))
# 輸出：你好2、base64 編碼解碼（文件）
# base64 【編碼】
import base64
def base64_encode_file(file_name):
with open(file_name, 'rb') as f:
return base64.b64encode(f.read()).decode('utf-8')
# 輸入
print(base64_encode_file("1.txt"))
# 輸出：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
# base64 【解碼】
import base64
def base64_decode_file(base64_data):
img_data = base64.b64decode(base64_data)
with open('1.jpg', 'wb') as f:
f.write(img_data)
# 輸入
base64_decode_file("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")
# 輸出：（是一個jpg圖片文件）
3、ASCLL碼 編碼解碼
# ASCLL【編碼】
def ASCLL_encode(string):
result = []
for a in string:
result = result + [ord(a)]
return result
# 輸入
print(ASCLL_encode('你好'))
# 輸出(列表)：[20320, 22909]
# ASCLL【解碼】
def ASCLL_decode(string):
result = ""
for a in eval(string):
result = result + chr(a)
return result
# 輸入(列表)
print(ASCLL_decode('[20320, 22909]'))
# 輸出：你好
4、Unicode編碼解碼
# Unicode 【編碼】 （僅對中文有效）
def str_to_unicode(str_data):
return str_data.encode('unicode_escape').decode('utf-8')
# 輸入
print(str_to_unicode('你好'))
# 輸出：\u4f60\u597d
# Unicode 【解碼】
def unicode_to_str(unicode_str):
return unicode_str
# 輸入
print(unicode_to_str('\u4f60\u597d'))
# 輸出：你好
5、UTF-8編碼解碼
# UTF-8 【編碼】
def utf8_encode(str_data):
return str_data.encode('utf-8')
# 輸入
print(utf8_encode('你好'))
# 輸出：b'\xe4\xbd\xa0\xe5\xa5\xbd'
# UTF-8 【解碼】
# 輸入
print(b'\xe4\xbd\xa0\xe5\xa5\xbd'.decode('utf-8'))
# 輸出：你好
6、URL 編碼解碼
# 方法一
# URL 【編碼】 （僅對中文有效）
import urllib.parse
def URL_encode(url):
return urllib.parse.quote(url)
# 輸入
print(URL_encode('你好'))
# 輸出：%E4%BD%A0%E5%A5%BD
# 方法二
# URL 【編碼】 （對所有字符串有效）
def URL_encode(url):
return ''.join([hex(ord(c)).replace('0x', '%') for c in url])
# 輸入
print(URL_encode('http://www.baidu.com'))
# 輸出：%68%74%74%70%3a%2f%2f%77%77%77%2e%62%61%69%64%75%2e%63%6f%6d
# URL 【解碼】
import urllib.parse
def URL_decode(url):
return urllib.parse.unquote(url)
# 輸入
print(URL_decode('%E4%BD%A0%E5%A5%BD'))
# 輸出：你好
7、摩斯密碼 編碼解碼
# 摩斯密碼字典 【必備 必須添加】（后續(xù)會更新更多）
# 摩斯密碼會把正常的英文都統(tǒng)一為大寫，輸出會變?yōu)榇髮?
# ！?。?！加解密有限制，只能對 【英文和數(shù)字】 進行加解密。字典需更新
MORSE_CODE_DICT = {
'A':'.-','B':'-...','C':'-.-.','D':'-..',
'E':'.','F':'..-.','G':'--.','H':'....',
'I':'..', 'J':'.---', 'K':'-.-',
'L':'.-..', 'M':'--', 'N':'-.','O':'---', 'P':'.--.', 'Q':'--.-',
'R':'.-.', 'S':'...', 'T':'-',
'U':'..-', 'V':'...-', 'W':'.--',
'X':'-..-', 'Y':'-.--', 'Z':'--..',
'1':'.----', '2':'..---', '3':'...--',
'4':'....-', '5':'.....', '6':'-....',
'7':'--...', '8':'---..', '9':'----.',
'0':'-----', ', ':'--..--', '.':'.-.-.-',
'?':'..--..', '/':'-..-.', '-':'-....-',
'(':'-.--.', ')':'-.--.-',' ':' '}# 摩斯密碼【加密】 (通用版) 與互聯(lián)網(wǎng)上的相匹配，可以通用，前提是字典要齊全
# 這個加密包不含空格，原本含有空格的字符串會被替換為無（不含空格的加密）
def morse_encode(message):
cipher = ''
set = 0
for letter in message.replace(' ','').upper():
if set == 1:
cipher += '/'
if letter != ' ':
cipher += MORSE_CODE_DICT[letter]
set = 1
return cipher
# 輸入
print(morse_encode('abc'))
# 輸出：.-/-.../-.-.# 摩斯密碼【解密】 (通用版) 與互聯(lián)網(wǎng)上的相匹配，可以通用，前提是字典要齊全
# （不含空格的解密）
def decode_morse_code(code):
code = code.replace('/',' ')
# 將摩斯密碼字符串按空格分割
code_list = code.split(' ')
# 定義解密后的字符串
decode_str = ''
# 遍歷摩斯密碼字符串列表
for code_str in code_list:
# 將摩斯密碼字符串從字典中取出對應(yīng)的字符
decode_str += list(MORSE_CODE_DICT.keys())[list(MORSE_CODE_DICT.values()).index(code_str)]
# 返回解密后的字符串
return decode_str
# 輸入
print(decode_morse_code('.-/-.../-.-.'))
# 輸出：ABC# 摩斯密碼【加密】 (修改版 私用) 加密后的摩斯密碼只能通過下面的那個腳本進行解密
# 這個加密包含空格，原本含有空格的字符串都會加密（加密含空格）
def morses_encode(message):
cipher = ''
set = 0
for letter in message.upper():
if set != 0:
cipher += '/'
if letter != ' ':
cipher += MORSE_CODE_DICT[letter]
set += 1
else:
set = 0
cipher += '&/'
return cipher
# 輸入
print(morses_encode('ab c'))
# 輸出：.-/-.../&/-.-.# 摩斯密碼【解密】 (修改版 私用) 也可以用于互聯(lián)網(wǎng)的加解密，可以通用，前提是字典要齊全
# （解密含空格）可通用
def decodes_morse_code(code):
code = code.replace('/',' ')
# 將摩斯密碼字符串按空格分割
code_list = code.split(' ')
# 定義解密后的字符串
decode_str = ''
# 遍歷摩斯密碼字符串列表
for code_str in code_list:
if code_str == '&':
decode_str += ' '
else:
# 將摩斯密碼字符串從字典中取出對應(yīng)的字符
decode_str += list(MORSE_CODE_DICT.keys())[list(MORSE_CODE_DICT.values()).index(code_str)]
# 返回解密后的字符串
return decode_str
# 輸入
print(decodes_morse_code('.-/-.../&/-.-.'))
# 輸出：AB C8、hexstr 編碼解碼
<code class="language-plaintext hljs"># hexstr 【編碼】
import binascii
def hexstr_encode(data):
return binascii.b2a_hex(data.encode()).decode()
# 輸入
print(hexstr_encode('你好'))
# 輸出：e4bda0e5a5bd</code>
<code class="language-plaintext hljs"># hexstr 【解碼】
import binascii
def encode_hexstr(data):
return binascii.a2b_hex(data).decode()
# 輸入
print(encode_hexstr('e4bda0e5a5bd'))
# 輸出：你好</code>
四、字符串轉(zhuǎn)換
1、中文&繁體
# 簡體轉(zhuǎn)繁體
import opencc
def convert_opencc(text):
return opencc.OpenCC('s2t').convert(text)
# 輸入
print(convert_opencc('線類'))
# 輸出：線類
# 繁體轉(zhuǎn)簡體
import opencc
def opencc_convert(text):
return opencc.OpenCC('t2s').convert(text)
# 輸入
print(opencc_convert('線類'))
# 輸出：線類
2、字符串 大寫&小寫
# 字符串轉(zhuǎn)大寫
def exchange_upper(str):
return str.upper()
# 輸入
print(exchange_upper('abc'))
# 輸出：ABC
# 字符串轉(zhuǎn)小寫
def exchange_lower(str):
return str.lower()
# 輸入
print(exchange_lower('ABC'))
# 輸出：abc
3、字符串 全角&半角
# 半角轉(zhuǎn)全角
def strB2Q(ustring):
"""半角轉(zhuǎn)全角"""
rstring = ""
for uchar in ustring:
inside_code=ord(uchar)
if inside_code == 32: # 半角空格直接轉(zhuǎn)化
inside_code = 12288
elif inside_code >= 32 and inside_code <= 126: # 半角字符（除空格）根據(jù)關(guān)系轉(zhuǎn)化
inside_code += 65248
rstring += chr(inside_code)
return rstring
# 輸入
print(strB2Q('123abc'))
# 輸出：１２３ａｂｃ# 全角轉(zhuǎn)半角
def strQ2B(ustring):
"""全角轉(zhuǎn)半角"""
rstring = ""
for uchar in ustring:
inside_code = ord(uchar)
if inside_code == 12288: # 全角空格直接轉(zhuǎn)換
inside_code = 32
elif (inside_code >= 65281 and inside_code <= 65374): # 全角字符（除空格）根據(jù)關(guān)系轉(zhuǎn)化
inside_code -= 65248
rstring += chr(inside_code)
return rstring
# 輸入
print(strQ2B('１２３ａｂｃ'))
# 輸出：123abc4、時間戳 & 日期
# 日期轉(zhuǎn)時間戳
import time
def Unix_time(times):
# 轉(zhuǎn)換為時間戳,將"%Y-%m-%d %H:%M:%S"轉(zhuǎn)換為 1672989181字符串
return int(time.mktime(time.strptime(times, '%Y-%m-%d %H:%M:%S')))
# 輸入
print(Unix_time('2023-01-01 15:12:07'))
# 輸出：1672557127
# 時間戳轉(zhuǎn)日期
import time
def time_Unix(times):
# 轉(zhuǎn)換為其他日期格式,如:"%Y-%m-%d %H:%M:%S"
return time.strftime("%Y-%m-%d %H:%M:%S",time.localtime(times))
# 輸入
print(time_Unix('1672557127'))
# 輸出：2023-01-01 15:12:07
5、顏色 HEX & RGB & CMYK
# HEX 轉(zhuǎn) RGB(元組)
def hex_to_rgb(hex_color):
hex_color = hex_color.lstrip('#')
lv = len(hex_color)
return tuple(int(hex_color[i:i + lv // 3], 16) for i in range(0, lv, lv // 3))
# 輸入
print(hex_to_rgb('#FFFFFF'))
# 輸出(元組)：(255, 255, 255)
# RGB(元組) 轉(zhuǎn) HEX
def rgb_to_hex(rgb_color):
return '#%02x%02x%02x' % rgb_color
# 輸入(元組)
print(rgb_to_hex((255, 255, 255)))
# 輸出：#FFFFFF
# RGB(元組) 轉(zhuǎn) CMYK(元組)
def rgb_to_cmyk(rgb):
r = rgb[0] / 255.0
g = rgb[1] / 255.0
b = rgb[2] / 255.0
c = 1 - r
m = 1 - g
y = 1 - b
k = min(c, m, y)
c = (c - k) / (1 - k)
m = (m - k) / (1 - k)
y = (y - k) / (1 - k)
cmyk = (c, m, y, k)
return cmyk
# 輸入(元組)
print(rgb_to_cmyk((198, 254, 234)))
# 輸出(元組)：(0.2204724409448819, 0.0, 0.07874015748031502, 0.0039215686274509665)# CMYK(元組) 轉(zhuǎn) RGB(元組)
def cmyk_to_rgb(cmyk):
c = cmyk[0]
m = cmyk[1]
y= cmyk[2]
k = cmyk[3]
r = int(255 * (1 - c) * (1 - k))
g = int(255 * (1 - m) * (1 - k))
b = int(255 * (1 - y) * (1 - k))
rgb = (r, g, b)
return rgb
# 輸入(元組)
print(cmyk_to_rgb((0.2204724409448819, 0.0, 0.07874015748031502, 0.0039215686274509665)))
# 輸出(元組)：(198, 254, 234)
五、進制轉(zhuǎn)換
1、【2進制】 轉(zhuǎn) 4進制、8進制、10進制、16進制、32進制
# 2進制 轉(zhuǎn) 4進制
def binary_to_quaternary(binary):
# 將2進制轉(zhuǎn)換為10進制
decimal = int(binary, 2)
# 將10進制轉(zhuǎn)換為4進制
quaternary = ''
while decimal != 0:
remainder = decimal % 4
decimal = decimal // 4
quaternary = str(remainder) + quaternary
return quaternary
# 輸入
print(binary_to_quaternary('1101110110111'))
# 輸出：1232313
# 2進制 轉(zhuǎn) 8進制
# 輸入
print(oct(int('1101110110111',2))) # 2進制 轉(zhuǎn) 8進制
# 輸出：0o15667
# 2進制 轉(zhuǎn) 10進制
# 輸入
print(str(int('1101110110111',2))) # 2進制 轉(zhuǎn) 10進制
# 輸出：7095
# 2進制 轉(zhuǎn) 16進制
# 輸入
print(hex(int('1101110110111',2))) # 2進制 轉(zhuǎn) 16進制
# 輸出：0x1bb7
# 2進制 轉(zhuǎn) 32進制
def binary_to_base32(binary):
# 定義一個字典，用于存儲2進制到32進制的映射關(guān)系
base32_dict = {
'00000': '0',
'00001': '1',
'00010': '2',
'00011': '3',
'00100': '4',
'00101': '5',
'00110': '6',
'00111': '7',
'01000': '8',
'01001': '9',
'01010': 'A',
'01011': 'B',
'01100': 'C',
'01101': 'D',
'01110': 'E',
'01111': 'F',
'10000': 'G',
'10001': 'H',
'10010': 'I',
'10011': 'J',
'10100': 'K',
'10101': 'L',
'10110': 'M',
'10111': 'N',
'11000': 'O',
'11001': 'P',
'11010': 'Q',
'11011': 'R',
'11100': 'S',
'11101': 'T',
'11110': 'U',
'11111': 'V'
}
binary = (5 - len(binary) % 5) * '0' + binary
# 將2進制字符串轉(zhuǎn)換為列表
binary_list = list(binary)
# 將2進制列表轉(zhuǎn)換為5位2進制字符串的列表
binary_list_5 = [binary_list[i:i+5] for i in range(0, len(binary_list), 5)]
# 將2進制字符串列表轉(zhuǎn)換為32進制字符串
base32_str = ''
for binary_str in binary_list_5:
base32_str += base32_dict[''.join(binary_str)]
return base32_str
# 輸入
print(binary_to_base32('1101110110111'))
# 輸出：6TN2、【4進制】 轉(zhuǎn) 2進制、8進制、10進制、16進制、32進制
# 4進制 轉(zhuǎn) 2進制
# 輸入
print(bin(int('1101110110111',4)))
# 輸出：0b1010001010100010100010101
# 4進制 轉(zhuǎn) 8進制
# 輸入
print(oct(int('1101110110111',4)))
# 輸出：0o121242425
# 4進制 轉(zhuǎn) 10進制
# 輸入
print(str(int('1101110110111',4)))
# 輸出：21316885
# 4進制 轉(zhuǎn) 16進制
# 輸入
print(hex(int('1101110110111',4)))
# 輸出：0x1454515
# 4進制 轉(zhuǎn) 32進制
def binary_to_base32(binary):
# 4進制 轉(zhuǎn) 2進制
binary = bin(int(binary,4))
if binary[0:][:2] == '0b':
binary = binary.replace('0b','')
# 2進制 轉(zhuǎn) 32進制
# 定義一個字典，用于存儲2進制到32進制的映射關(guān)系
base32_dict = {
'00000': '0',
'00001': '1',
'00010': '2',
'00011': '3',
'00100': '4',
'00101': '5',
'00110': '6',
'00111': '7',
'01000': '8',
'01001': '9',
'01010': 'A',
'01011': 'B',
'01100': 'C',
'01101': 'D',
'01110': 'E',
'01111': 'F',
'10000': 'G',
'10001': 'H',
'10010': 'I',
'10011': 'J',
'10100': 'K',
'10101': 'L',
'10110': 'M',
'10111': 'N',
'11000': 'O',
'11001': 'P',
'11010': 'Q',
'11011': 'R',
'11100': 'S',
'11101': 'T',
'11110': 'U',
'11111': 'V'
}
binary = (5 - len(binary) % 5) * '0' + binary
# 將2進制字符串轉(zhuǎn)換為列表
binary_list = list(binary)
# 將2進制列表轉(zhuǎn)換為5位2進制字符串的列表
binary_list_5 = [binary_list[i:i+5] for i in range(0, len(binary_list), 5)]
# 將2進制字符串列表轉(zhuǎn)換為32進制字符串
base32_str = ''
for binary_str in binary_list_5:
base32_str += base32_dict[''.join(binary_str)]
return base32_str
# 輸入
print(binary_to_base32('11011101101111011'))
# 輸出：52KA5A53、【8進制】 轉(zhuǎn) 2進制、4進制、10進制、16進制、32進制
# 8進制 轉(zhuǎn) 2進制
# 輸入
print(bin(int('1101110110111',8)))
# 輸出：0b1001000001001001000001001000001001001
# 8進制 轉(zhuǎn) 4進制
def binary_to_quaternary(binary):
# 將8進制轉(zhuǎn)換為10進制
decimal = int(binary,8)
# 將10進制轉(zhuǎn)換為4進制
quaternary = ''
while decimal != 0:
remainder = decimal % 4
decimal = decimal // 4
quaternary = str(remainder) + quaternary
return quaternary
# 輸入
print(binary_to_quaternary('1101110110111'))
# 輸出：1020021020021001021# 8進制 轉(zhuǎn) 10進制
# 輸入
print(str(int('1101110110111',8)))
# 輸出：77462540361
# 8進制 轉(zhuǎn) 16進制
# 輸入
print(hex(int('1101110110111',8)))
# 輸出：0x1209209049
# 8進制 轉(zhuǎn) 32進制
def binary_to_base32(binary):
# 8進制 轉(zhuǎn) 2進制
binary = bin(int(binary,8))
if binary[0:][:2] == '0b':
binary = binary.replace('0b','')
# 2進制 轉(zhuǎn) 32進制
# 定義一個字典，用于存儲2進制到32進制的映射關(guān)系
base32_dict = {
'00000': '0',
'00001': '1',
'00010': '2',
'00011': '3',
'00100': '4',
'00101': '5',
'00110': '6',
'00111': '7',
'01000': '8',
'01001': '9',
'01010': 'A',
'01011': 'B',
'01100': 'C',
'01101': 'D',
'01110': 'E',
'01111': 'F',
'10000': 'G',
'10001': 'H',
'10010': 'I',
'10011': 'J',
'10100': 'K',
'10101': 'L',
'10110': 'M',
'10111': 'N',
'11000': 'O',
'11001': 'P',
'11010': 'Q',
'11011': 'R',
'11100': 'S',
'11101': 'T',
'11110': 'U',
'11111': 'V'
}
binary = (5 - len(binary) % 5) * '0' + binary
# 將2進制字符串轉(zhuǎn)換為列表
binary_list = list(binary)
# 將2進制列表轉(zhuǎn)換為5位2進制字符串的列表
binary_list_5 = [binary_list[i:i+5] for i in range(0, len(binary_list), 5)]
# 將2進制字符串列表轉(zhuǎn)換為32進制字符串
base32_str = ''
for binary_str in binary_list_5:
base32_str += base32_dict[''.join(binary_str)]
return base32_str
# 輸入
print(binary_to_base32('1101110110111'))
# 輸出：284I14294、【10進制】 轉(zhuǎn) 2進制、4進制、8進制、16進制、32進制
# 10進制 轉(zhuǎn) 2進制
# 輸入
print(bin(int('1101110110111',10)))
# 輸出：0b1001000001001001000001001000001001001
# 10進制 轉(zhuǎn) 4進制
def dec2four(num):
# 定義一個空列表，用于存放轉(zhuǎn)換后的四進制數(shù)
four_list = []
num = int(num)
# 循環(huán)，直到num為0
while num != 0:
# 將num除以4的余數(shù)添加到列表中
four_list.append(num % 4)
# 將num除以4，得到新的num
num = num // 4
# 將列表中的數(shù)字反轉(zhuǎn)
four_list.reverse()
# 將列表中的數(shù)字轉(zhuǎn)換為字符串
four_str = ''.join(str(i) for i in four_list)
# 返回轉(zhuǎn)換后的四進制數(shù)
return four_str
# 輸入
print(dec2four('1101110110111'))
# 輸出：100001133101232132133# 10進制 轉(zhuǎn) 8進制
# 輸入
print(oct(int('1101110110111',10)))
# 輸出：0o20013721563637
# 10進制 轉(zhuǎn) 16進制
# 輸入
print(hex(int('1101110110111',10)))
# 輸出：0x1005f46e79f
# 10進制 轉(zhuǎn) 32進制
def binary_to_base32(num, b = 32):
num = int(num)
return ((num == 0) and "0") or (binary_to_base32(num // b, b).lstrip("0") + "0123456789abcdefghijklmnopqrstuvwxyz"[num % b])
# 輸入
print(binary_to_base32('1101110110111'))
# 輸出：101fkdpsv
5、【16進制】 轉(zhuǎn) 2進制、4進制、8進制、10進制、32進制
# 16進制 轉(zhuǎn) 2進制
# 輸入
print(bin(int('1241241243',16)))
# 輸出：0b1001001000001001001000001001001000011
# 16進制 轉(zhuǎn) 4進制
def binary_to_quaternary(binary):
# 將16進制轉(zhuǎn)換為10進制
decimal = int(binary, 16)
# 將10進制轉(zhuǎn)換為4進制
quaternary = ''
while decimal != 0:
remainder = decimal % 4
decimal = decimal // 4
quaternary = str(remainder) + quaternary
return quaternary
# 輸入
print(binary16_to_quaternary('1241241243'))
# 輸出：1021001021001021003
# 16進制 轉(zhuǎn) 8進制
# 輸入
print(oct(int('1241241243',16)))
# 輸出：0o1110111011103
# 16進制 轉(zhuǎn) 10進制
# 輸入
print(str(int('1241241243',16)))
# 輸出：78402294339
# 16進制 轉(zhuǎn) 32進制
def binary_to_base32(binary):
# 16進制 轉(zhuǎn) 2進制
binary = bin(int(binary,16))
if binary[0:][:2] == '0b':
binary = binary.replace('0b','')
# 2進制 轉(zhuǎn) 32進制
# 定義一個字典，用于存儲2進制到32進制的映射關(guān)系
base32_dict = {
'00000': '0',
'00001': '1',
'00010': '2',
'00011': '3',
'00100': '4',
'00101': '5',
'00110': '6',
'00111': '7',
'01000': '8',
'01001': '9',
'01010': 'A',
'01011': 'B',
'01100': 'C',
'01101': 'D',
'01110': 'E',
'01111': 'F',
'10000': 'G',
'10001': 'H',
'10010': 'I',
'10011': 'J',
'10100': 'K',
'10101': 'L',
'10110': 'M',
'10111': 'N',
'11000': 'O',
'11001': 'P',
'11010': 'Q',
'11011': 'R',
'11100': 'S',
'11101': 'T',
'11110': 'U',
'11111': 'V'
}
binary = (5 - len(binary) % 5) * '0' + binary
# 將2進制字符串轉(zhuǎn)換為列表
binary_list = list(binary)
# 將2進制列表轉(zhuǎn)換為5位2進制字符串的列表
binary_list_5 = [binary_list[i:i+5] for i in range(0, len(binary_list), 5)]
# 將2進制字符串列表轉(zhuǎn)換為32進制字符串
base32_str = ''
for binary_str in binary_list_5:
base32_str += base32_dict[''.join(binary_str)]
return base32_str
# 輸入
print(binary16_to_base32('1241241243'))
# 輸出：290I84I36、【32進制】 轉(zhuǎn) 2進制、4進制、8進制、10進制、16進制
# 32進制 轉(zhuǎn) 2進制
# 輸入
print(bin(int('123456789',32)))
# 輸出：0b10001000011001000010100110001110100001001
# 32進制 轉(zhuǎn) 4進制
def binary_to_quaternary(binary):
# 將32進制轉(zhuǎn)換為10進制
decimal = int(binary, 32)
# 將10進制轉(zhuǎn)換為4進制
quaternary = ''
while decimal != 0:
remainder = decimal % 4
decimal = decimal // 4
quaternary = str(remainder) + quaternary
return quaternary
# 輸入
print(binary_to_quaternary('123456789'))
# 輸出：101003020110301310021
# 32進制 轉(zhuǎn) 8進制
# 輸入
print(oct(int('123456789',32)))
# 輸出：0o21031024616411
# 32進制 轉(zhuǎn) 10進制
# 輸入
print(str(int('123456789',32)))
# 輸出：1171591994633
# 32進制 轉(zhuǎn) 16進制
# 輸入
print(hex(int('123456789',32)))
# 輸出：0x110c8531d09以上就是Python實現(xiàn)加解密,編碼解碼和進制轉(zhuǎn)換(最全版)的詳細內(nèi)容，更多關(guān)于Python加解密 編碼解碼 進制轉(zhuǎn)換的資料請關(guān)注腳本之家其它相關(guān)文章！
相關(guān)文章
這篇文章主要介紹了Python根據(jù)站點列表繪制站坐標全球分布圖,輸入站點列表文件、snx全球站點坐標文件，本文通過示例代碼給大家介紹的非常詳細，需要的朋友可以參考下2021-12-12
教你如何用Pytorch搭建數(shù)英混合驗證碼圖片識別模型
大家都知道checkpoints存放的是模型文件，data存放的是數(shù)據(jù)集，本文給大家分享如何利用Pytorch搭建數(shù)英混合驗證碼圖片識別模型包括普通卷積模塊，深度可分離卷積模塊，空間通道注意力模塊，殘差模塊，感興趣的朋友跟隨小編一起看看吧2024-04-04
Python scrapy增量爬取實例及實現(xiàn)過程解析
這篇文章主要介紹了Python scrapy增量爬取實例及實現(xiàn)過程解析,文中通過示例代碼介紹的非常詳細，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值,需要的朋友可以參考下2019-12-12
python使用隱式循環(huán)快速求和的實現(xiàn)示例
這篇文章主要介紹了python使用隱式循環(huán)快速求和的實現(xiàn)示例，文中通過示例代碼介紹的非常詳細，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2020-09-09
在PyCharm中安裝PyTorch、torchvision和OpenCV詳解
這篇文章主要介紹了在PyCharm中安裝PyTorch、torchvision和OpenCV方式,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教2025-04-04
這篇文章主要介紹了如何使用Python腳本實現(xiàn)文件拷貝,文中通過示例代碼介紹的非常詳細，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值,需要的朋友可以參考下2019-11-11
這篇文章主要介紹了簡單的Apache+FastCGI+Django配置指南,這也是Python上最流行的web框架Django的最流行搭配環(huán)境:)需要的朋友可以參考下2015-07-07
分段函數(shù)是一種數(shù)學(xué)函數(shù),它將定義域分成若干個區(qū)間,每個區(qū)間對應(yīng)一個函數(shù),本文主要介紹了python分段函數(shù)的實現(xiàn)示例,具有一定的參考價值,感興趣的可以了解一下2023-12-12
這篇文章主要介紹了Python中的多重繼承,是Python學(xué)習(xí)中的基本知識,代碼基于Python2.x版本,需要的朋友可以參考下2015-04-04
TaLib是一個Python金融指數(shù)處理庫,包含了很多技術(shù)分析里的常用參數(shù)指標,例如MA、SMA、WMA、MACD、ATR等,這篇文章主要給大家介紹了關(guān)于python安裝TA-Lib庫報錯問題的解決方法,需要的朋友可以參考下2024-01-01