Python应用知识点

下载链接图片

项目中用到的网络请求图片，并返回图片，记录下

import base64
import requests
import io
from PIL import Image

# 头像下载
def iconLoad(path):
	try:
		resp = requests.get(path, stream=True)  # 网络请求图片
		image = Image.open(io.BytesIO(resp.content))  # image打开，已转换的字节流图片
		imgBytesArr = io.BytesIO()  # 创建 空字节流对象
		image.save(imgBytesArr, format='gif')  # 保存
		img_base64 = base64.b64encode(imgBytesArr.getValue().decode('utf-8'))  # 转换base64字符串
		return img_base64
	except Excetion as e:
		return ''

加密压缩，解密压缩

import os
import hashlib

def makePwd(pwd):

    p_m = hashlib.md5()
    p_m.update(pwd.encode())
    res = p_m.hexdigest()
    return res


# cmd命令执行的方式还有两种，一种是 os.system()，一种是 os.popen()，亲测两种速度有较大的区别，后者速度比前者速度快很多，
# 一张图片压缩加密，os.system()速度是0.02493429183959961，而os.popen()是0.000997304916381836，足足快了22倍多，
# 多张图片，os.system()速度是0.06981277465820312，而os.popen()0.0019953250885009766，速度快了50倍


# 使用命令，压缩、加密单个文件
def makezip(file, zipfile, pwd):
    loc_7z = r'C:\"Program Files\7-Zip"\7z.exe'  # 7zip开源压缩工具的可执行文件路径
    archive_command_str = loc_7z + " a " + zipfile + " -p" + pwd + " " + file.__str__()  # 编辑命令行
    print(archive_command_str)
    # os.system(archive_command_str)
    os.popen(archive_command_str)


# 使用命令，压缩多个文件
def makezip_unps(zipfile, *files):
    loc_7z = r'C:\"Program Files\7-Zip"\7z.exe'
    archive_command_str = loc_7z + " a " + zipfile
    for file in files:
        archive_command_str += " " + file.__str__()
    print(archive_command_str)
    os.system(archive_command_str)





def deCryptZip(file, password, deDir):
    p_m = hashlib.md5()
    p_m.update(password.encode())
    pwd = p_m.hexdigest()
    loc_7z = r'C:\"Program Files\7-Zip"\7z.exe'
    archive_command_str = loc_7z + " x -p" + pwd + " " + file + " -o" + deDir  # 编辑命令行
    print(archive_command_str)
    os.popen(archive_command_str)


if __name__ == '__main__':

    import time
    file = r'C:\Users\admin\Desktop\info.xls'
    zipfile = 'tmp.zip'
    # pwd = str(time.time() + 8888)
    pwd = '123456'
    print('加密压缩')
    makezip(file, zipfile, makePwd(pwd))


    print('解密解压')
    # deCryptZip(r'D:\project\scanDemo\scantest\tmp.zip', pwd, r'C:\Users\admin\Desktop\test')
    deCryptZip('./tmp.zip', pwd, r'C:\Users\admin\Desktop\test')

运行 7z.exe 后可以看到命令行中列出了可用的命令行命令：

a：将文件添加到压缩档案中
b：测试压缩或解压算法执行时的 CPU 占用
d：从压缩档案中删除文件
e：将压缩档案中的所有文件解压到指定路径，所有文件将输出到同一个目录中
h：计算文件的哈希值
i：显示有关支持格式的信息
l：列出压缩档案的内容
rn：重命名压缩档案中的文件
t：测试压缩档案的完整性
u：更新要进入压缩档案中的文件
x：将压缩档案中的所有文件解压到指定路径，并包含所有文件的完整路径

加密解密

DES：DES全称为Data Encryption Standard，即数据加密标准，是一种使用密钥加密的块算法。

3DES：3DES（或称为Triple DES）是三重数据加密算法（TDEA，Triple Data Encryption Algorithm）块密码的通称。它相当于是对每个数据块应用三次DES加密算法。由于计算机运算能力的增强，原版DES密码的密钥长度变得容易被暴力破解；3DES即是设计用来提供一种相对简单的方法，即通过增加DES的密钥长度来避免类似的攻击，而不是设计一种全新的块密码算法。

# -*- coding:utf-8 -*-
import base64
import binascii

from Crypto.Cipher import DES3
from pyDes import des, CBC, PAD_PKCS5

class Des_encryption:


    def des_encrypt(self, secret_key, s):
        iv = secret_key
        k = des(secret_key, CBC, iv, pad=None, padmode=PAD_PKCS5)
        en = k.encrypt(s, padmode=PAD_PKCS5)
        return binascii.b2a_hex(en)

    def des_decrypt(self, secret_key, s):
        iv = secret_key
        k = des(secret_key, CBC, iv, pad=None, padmode=PAD_PKCS5)
        de = k.decrypt(binascii.a2b_hex(s), padmode=PAD_PKCS5)
        return de


class ThreeDes_encryption:
    def __init__(self, key):
        self.key = key  # 初始化密钥
        self.iv = b'01234567'  # 偏移量
        self.length = DES3.block_size  # 初始化数据块大小
        self.des3 = DES3.new(self.key, DES3.MODE_CBC, self.iv)  # 初始化AES,CBC模式的实例
        # 截断函数，去除填充的字符
        self.unpad = lambda date: date[0:-ord(date[-1])]

    def pad(self, text):
        """
        #填充函数，使被加密数据的字节码长度是block_size的整数倍
        """
        count = len(text.encode('utf-8'))
        add = self.length - (count % self.length)
        entext = text + (chr(add) * add)
        return entext

    def encrypt(self, encrData):  # 加密函数

        res = self.des3.encrypt(self.pad(encrData).encode("utf-8"))
        msg = str(base64.b64encode(res), encoding="utf-8")
        # msg =  res.hex()
        return msg

    def decrypt(self, decrData):  # 解密函数
        res = base64.decodebytes(decrData.encode("utf-8"))
        # res = bytes.fromhex(decrData)
        msg = self.des3.decrypt(res).decode("utf-8")
        return self.unpad(msg)



if __name__ == '__main__':
    print('des:')
    s = Des_encryption()
    params = 'marname=sky'

    secret_key = 'scan_key'
    params_encrypt = s.des_encrypt(secret_key, params)
    params_decrypt = s.des_decrypt(secret_key, params_encrypt)
    print(params_encrypt)
    print(params_decrypt)


    print('3des:')
    Three_secret_key = '_duoyi_scan_key_'
    t = ThreeDes_encryption(Three_secret_key)

    # params_3encrypt = t.encrypt(params)
    # print(params_3encrypt)

    params_3encrypt = 'KO+16hwoN0tpOCLcchmIGQ =='
    params_3decrypt = t.decrypt(params_3encrypt)
    print(params_3decrypt)

AES：密码学中的高级加密标准（Advanced Encryption Standard，AES），又称Rijndael加密法。

# -*- coding:utf-8 -*-
import binascii
from Crypto.Cipher import AES

#加密内容需要长达16位字符，所以进行空格拼接
# CBC模式
class crypt_util():
    def __init__(self, key):
        self.token = key.encode('utf-8')
        self.aes = AES.new(self.token, AES.MODE_CBC, b'0000000000000000')

    def encrypt(self, text):
        text = text.encode('utf-8')
        # 这里密钥key 长度必须为16（AES-128）,
        # 24（AES-192）,或者32 （AES-256）Bytes 长度
        # 目前AES-128 足够目前使用
        length = 16
        count = len(text)
        if count < length:
            add = (length - count)
            # \0 backspace
            # text = text + ('\0' * add)
            text = text + ('\0' * add).encode('utf-8')
        elif count > length:
            add = (length - (count % length))
            # text = text + ('\0' * add)
            text = text + ('\0' * add).encode('utf-8')
        self.ciphertext = self.aes.encrypt(text)
        # 因为AES加密时候得到的字符串不一定是ascii字符集的，输出到终端或者保存时候可能存在问题
        # 所以这里统一把加密后的字符串转化为16进制字符串
        return binascii.b2a_hex(self.ciphertext)



    def decrypt(self,str):
        plain_text = self.aes.decrypt(binascii.a2b_hex(str))
        # return plain_text.rstrip('\0')
        print(bytes.decode(plain_text).rstrip('\0'))
        return bytes.decode(plain_text).rstrip('\0')

        # # a = b'8fea87a50aa6203cfcfd508fa30f8fa0d8cd103e3a37ef057f7763eff7742b51'
        # # 用aes对象进行解密，将字节类型转为str类型，错误编码忽略不计
        # de = self.aes.decrypt(binascii.a2b_hex(str)), encoding='utf-8', errors="ignore")
        # # 获取str从0开始到文本内容的字符串长度。
        # print(de)
        # return de

    def pad(text):
        while len(text) % 16 != 0:
            text += b' '
        return text
    #加密秘钥需要长达16位字符，所以进行空格拼接
    def pad_key(key):
        while len(key) % 16 != 0:
            key += b' '
        return key


if __name__ == '__main__':
    key = 'duoyi_common_key'
    crypt = crypt_util(key)
    params = 'marname=sky'
    # s = crypt.encrypt(params)
    s = b'5afb157e43d9c0319e6830212d15bbcc'
    # print(s)
    # print(params)
    crypt.decrypt(s)

"""
ECB没有偏移量
"""
from Crypto.Cipher import AES
import base64

key = 'sky_demo_pub_key'
block_size = 16

def add_to_16(text):
    if len(text.encode('utf-8')) % block_size:
        add = block_size - (len(text.encode('utf-8')) % block_size)
    else:
        add = 0
    text = text + ('\0' * add)
    return text.encode('utf-8')


# 加密函数
def encrypt(text):
    mode = AES.MODE_ECB
    text = add_to_16(text)
    cryptos = AES.new(key.encode('uft-8'), mode)
    cipher_text = cryptos.encrypt(text)
    result = base64.b64encode(cipher_text)
    return result.decode('utf-8')


# 解密后，去掉补足的空格用strip() 去掉
def decrypt(text):
    mode = AES.MODE_ECB
    cryptor = AES.new(key.encode('utf-8'), mode)
    cipher_text = base64.b64decode(text)
    plain_text = cryptor.decrypt(cipher_text)
    res = bytes.decode(plain_text).rstrip('\0')
    return eval(res)

获取ip

x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')  # 判断是否使用代理
if x_forwarded_for:  # yes
    ip = x_forwarded_for.split(',')[0]  # 使用代理获取真实IP
    return response.responseWithData('使用代理获取真实IP', ip)
else:
    ip = request.META.get("REMOTE_ADDR")  # 获取IP
    return response.responseWithData('获取IP', ip)

中间件

用于过滤请求，登录判断，异常处理

from utils import response as Resp
from django.utils.deprecation import MiddlewareMixin


class RequestMiddleware(MiddlewareMixin):

  # # 中间件函数。(用到哪个函数写哪个，不需要全写)
  def process_request(self, request):
    '''产生request对象之后，url匹配之前调用'''
    if 'update' in request.path:
      return Resp.failResponse('process_request fail')


  # 默认放行,不拦截请求。
  def process_view(self, request, view, args, kwargs):
    '''url匹配之后，视图函数调用之前调用'''
    # view_func: url匹配到的视图函数。
    # if 'update' in request.path:
    #   return Resp.failResponse('process_view fail')

  

  # def process_response(self, request, response):
  #   '''视图函数调用之后，response返回浏览器之前'''
  #   pass

  # 如果注册多个process_exception函数，那么函数的执行顺序与注册的顺序相反。(其他中间件函数与注册顺序一致)
  # 中间件函数，用到哪个就写哪个，不需要写所有的中间件函数。
  def process_exception(self, request, exception):
    '''视图函数发生异常时调用'''
    return Resp.failResponse(str(exception))

快捷访问目录文件

python3 -m http.sever 9999

在那个目录下启动的这条指令

其它机器可以通过下列链接 看到它启动目录下的文件
http://ip:9999

django优化查询语句之select_related与prefetch_related函数

在数据库有外键的时候,使用select_related()和prefetch_related()可以很好的减少数据库请求的次数,从而提高性能.这两个方法都是避免因访问外键对象而导致的数据库查询泛滥，但策略却大不相同。

*select_related(fields)

作用和方法：JOIN关联一次性查询，减少查询次数。

作用对象：该方法只作用于一对多（普通外键 ForeignKey）或者一对一（OneToOneField）关系。

*prefetch_related( lookups)

作用和方法：分别查询每个表，然后用Python处理他们之间的关系。

作用对象：对于多对多字段（ManyToManyField）和一对多字段（ ForeignKey）

总结：
select_related主要针一对一和多对一关系进行优化。
select_related使用SQL的JOIN语句进行优化，通过减少SQL查询的次数来进行优化、提高性能。
可以通过可变长参数指定需要select_related的字段名。也可以通过使用双下划线“__”连接字段名来实现指定的递归查询。没有指定的字段不会缓存，没有指定的深度不会缓存，如果要访问的话Django会再次进行SQL查询。
也可以通过depth参数指定递归的深度，Django会自动缓存指定深度内所有的字段。如果要访问指定深度外的字段，Django会再次进行SQL查询。

因为select_related()总是在单次SQL查询中解决问题，而prefetch_related()会对每个相关表进行SQL查询，因此select_related()的效率通常比后者高。鉴于此，尽可能的用select_related()解决问题。只有在select_related()不能解决问题的时候再去想prefetch_related()。
你可以在一个QuerySet中同时使用select_related()和prefetch_related()，从而减少SQL查询的次数。只有prefetch_related()之前的select_related()是有效的，之后的将会被无视掉。