接：写了个自动批改小孩作业的代码（上）

2.4 切割图像

上帝说要有光，就有了光。

于是，当光投过来时，物体的背后就有了影。

我们就知道了，有影的地方就有东西，没影的地方是空白。

这就是投影。

这个简单的道理放在图像切割上也很实用。

我们把文字的像素做个投影，这样我们就知道某个区间有没有文字，并且知道这个区间文字是否集中。

下面是示意图：

2.4.1 投影大法

最有效的方法，往往都是用循环实现的。

要计算投影，就得一个像素一个像素地数，查看有几个像素，然后记录下这一行有N个像素点。如此循环。

首先导入包：

import numpy as np
import cv2
from PIL import Image, ImageDraw, ImageFont
import PIL
import matplotlib.pyplot as plt
import os
import shutil
from numpy.core.records import array
from numpy.core.shape_base import block
import time

比如说要看垂直方向的投影，代码如下：

# 整幅图片的Y轴投影，传入图片数组，图片经过二值化并反色
def img_y_shadow(img_b):
    ### 计算投影 ###
    (h,w)=img_b.shape
    # 初始化一个跟图像高一样长度的数组，用于记录每一行的黑点个数
    a=[0 for z in range(0,h)]
    # 遍历每一列，记录下这一列包含多少有效像素点
    for i in range(0,h):          
        for j in range(0,w):      
            if img_b[i,j]==255:     
                a[i]+=1  
    return a

最终得到是这样的结构：[0, 79, 67, 50, 50, 50, 109, 137, 145, 136, 125, 117, 123, 124, 134, 71, 62, 68, 104, 102, 83, 14, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, ……38, 44, 56, 106, 97, 83, 0, 0, 0, 0, 0, 0, 0]表示第几行总共有多少个像素点，第1行是0，表示是空白的白纸，第2行有79个像素点。

如果我们想要从视觉呈现出来怎么处理呢？那可以把它立起来拉直画出来。

# 展示图片
def img_show_array(a):
    plt.imshow(a)
    plt.show()
    
# 展示投影图， 输入参数arr是图片的二维数组，direction是x,y轴
def show_shadow(arr, direction = 'x'):

    a_max = max(arr)
    if direction == 'x': # x轴方向的投影
        a_shadow = np.zeros((a_max, len(arr)), dtype=int)
        for i in range(0,len(arr)):
            if arr[i] == 0:
                continue
            for j in range(0, arr[i]):
                a_shadow[j][i] = 255
    elif direction == 'y': # y轴方向的投影
        a_shadow = np.zeros((len(arr),a_max), dtype=int)
        for i in range(0,len(arr)):
            if arr[i] == 0:
                continue
            for j in range(0, arr[i]):
                a_shadow[i][j] = 255

    img_show_array(a_shadow)

我们来试验一下效果：

我们将上面的原图片命名为question.jpg放到代码同级目录。

# 读入图片
img_path = 'question.jpg'
img=cv2.imread(img_path,0) 
thresh = 200 
# 二值化并且反色
ret,img_b=cv2.threshold(img,thresh,255,cv2.THRESH_BINARY_INV) 

二值化并反色后的变化如下所示：

上面的操作很有作用，通过二值化，过滤掉杂色，通过反色将黑白对调，原来白纸区域都是255，现在黑色都是0，更利于计算。

计算投影并展示的代码：

img_y_shadow_a = img_y_shadow(img_b)
show_shadow(img_y_shadow_a, 'y') # 如果要显示投影

下面的图是上面图在Y轴上的投影

从视觉上看，基本上能区分出来哪一行是哪一行。

2.4.2 根据投影找区域

最有效的方法，往往还得用循环来实现。

上面投影那张图，你如何计算哪里到哪里是一行，虽然肉眼可见，但是计算机需要规则和算法。

# 图片获取文字块，传入投影列表，返回标记的数组区域坐标[[左，上，右，下]]
def img2rows(a,w,h):
    
    ### 根据投影切分图块 ### 
    inLine = False # 是否已经开始切分
    start = 0 # 某次切分的起始索引
    mark_boxs = []
    for i in range(0,len(a)):        
        if inLine == False and a[i] > 10:
            inLine = True
            start = i
        # 记录这次选中的区域[左，上，右，下]，上下就是图片，左右是start到当前
        elif i-start >5 and a[i] < 10 and inLine:
            inLine = False
            if i-start > 10:
                top = max(start-1, 0)
                bottom = min(h, i+1)
                box = [0, top, w, bottom]
                mark_boxs.append(box) 
                
    return mark_boxs

通过投影，计算哪些区域在一定范围内是连续的，如果连续了很长时间，我们就认为是同一区域，如果断开了很长一段时间，我们就认为是另一个区域。

通过这项操作，我们就可以获得Y轴上某一行的上下两个边界点的坐标，再结合图片宽度，其实我们也就知道了一行图片的四个顶点的坐标了mark_boxs存下的是[坐，上，右，下]。

如果调用如下代码：

(img_h,img_w)=img.shape
row_mark_boxs = img2rows(img_y_shadow_a,img_w,img_h)
print(row_mark_boxs)

我们获取到的是所有识别出来每行图片的坐标，格式是这样的：[[0, 26, 596, 52], [0, 76, 596, 103], [0, 130, 596, 155], [0, 178, 596, 207], [0, 233, 596, 259], [0, 282, 596, 311], [0, 335, 596, 363], [0, 390, 596, 415]]

2.4.3 根据区域切图片

最有效的方法，最终也得用循环来实现。这也是计算机体现它强大的地方。

# 裁剪图片,img 图片数组， mark_boxs 区域标记

def cut_img(img, mark_boxs):



    img_items = [] # 存放裁剪好的图片

    for i in range(0,len(mark_boxs)):

        img_org = img.copy()

        box = mark_boxs[i]

        # 裁剪图片

        img_item = img_org[box[1]:box[3], box[0]:box[2]]

        img_items.append(img_item)

    return img_items

这一步骤是拿着方框，从大图上用小刀划下小图，核心代码是img_org[box[1]:box[3], box[0]:box[2]]图片裁剪，参数是数组的[上：下，左：右]，获取的数据还是二维的数组。

如果保存下来：

# 保存图片
def save_imgs(dir_name, imgs):
 
    if os.path.exists(dir_name):
        shutil.rmtree(dir_name) 
    if not os.path.exists(dir_name):    
        os.makedirs(dir_name)

    img_paths = []
    for i in range(0,len(imgs)):
        file_path = dir_name+'/part_'+str(i)+'.jpg'
        cv2.imwrite(file_path,imgs[i])
        img_paths.append(file_path)
    
    return img_paths

# 切图并保存
row_imgs = cut_img(img, row_mark_boxs)
imgs = save_imgs('rows', row_imgs) # 如果要保存切图
print(imgs)

图片是下面这样的：

2.4.4 循环可去油腻

还是循环。横着行我们掌握了，那么针对每一行图片，我们竖着切成三块是不是也会了，一个道理。

需要注意的是，横竖是稍微有区别的，下面是上图的x轴投影。

横着的时候，字与字之间本来就是有空隙的，然后块与块也有空隙，这个空隙的度需要掌握好，以便更好地区分出来是字的间距还是算式块的间距。

幸好，有种方法叫膨胀。

膨胀对人来说不积极，但是对于技术来说，不管是膨胀（dilate），还是腐蚀（erode），只要能达到目的，都是好的。

kernel=np.ones((3,3),np.uint8)  # 膨胀核大小
row_img_b=cv2.dilate(img_b,kernel,iterations=6) # 图像膨胀6次

膨胀之后再投影，就很好地区分出了块。

根据投影裁剪之后如下图所示：

同理，不膨胀可截取单个字符。

这样，这是一块区域的字符。

一行的，一页的，通过循环，都可以截取出来。

有了图片，就可以识别了。有了位置，就可以判断识别结果的关系了。

下面提供一些代码，这些代码不全，有些函数你可能找不到，但是思路可以参考，详细的代码可以去我的github去看。

def divImg(img_path, save_file = False):

    img_o=cv2.imread(img_path,1) 
    # 读入图片
    img=cv2.imread(img_path,0) 
    (img_h,img_w)=img.shape
    thresh = 200
    # 二值化整个图，用于分行
    ret,img_b=cv2.threshold(img,thresh,255,cv2.THRESH_BINARY_INV) 

    # 计算投影，并截取整个图片的行
    img_y_shadow_a = img_y_shadow(img_b)
    row_mark_boxs = img2rows(img_y_shadow_a,img_w,img_h)
    # 切行的图片，切的是原图
    row_imgs = cut_img(img, row_mark_boxs)
    all_mark_boxs = []
    all_char_imgs = []
    # ===============从行切块======================
    for i in range(0,len(row_imgs)):
        row_img = row_imgs[i]
        (row_img_h,row_img_w)=row_img.shape
        # 二值化一行的图，用于切块
        ret,row_img_b=cv2.threshold(row_img,thresh,255,cv2.THRESH_BINARY_INV)
        kernel=np.ones((3,3),np.uint8)
        #图像膨胀6次
        row_img_b_d=cv2.dilate(row_img_b,kernel,iterations=6)
        img_x_shadow_a = img_x_shadow(row_img_b_d)
        block_mark_boxs = row2blocks(img_x_shadow_a, row_img_w, row_img_h)
        row_char_boxs = []
        row_char_imgs = []
        # 切块的图，切的是原图
        block_imgs = cut_img(row_img, block_mark_boxs)
        if save_file:
            b_imgs = save_imgs('cuts/row_'+str(i), block_imgs) # 如果要保存切图
            print(b_imgs)
        # =============从块切字====================
        for j in range(0,len(block_imgs)):
            block_img = block_imgs[j]
            (block_img_h,block_img_w)=block_img.shape
            # 二值化块,因为要切字符图片了
            ret,block_img_b=cv2.threshold(block_img,thresh,255,cv2.THRESH_BINARY_INV)
            block_img_x_shadow_a = img_x_shadow(block_img_b)
            row_top = row_mark_boxs[i][1]
            block_left = block_mark_boxs[j][0]
            char_mark_boxs,abs_char_mark_boxs = block2chars(block_img_x_shadow_a, block_img_w, block_img_h,row_top,block_left)
            row_char_boxs.append(abs_char_mark_boxs)
            # 切的是二值化的图
            char_imgs = cut_img(block_img_b, char_mark_boxs, True)
            row_char_imgs.append(char_imgs)
            if save_file:
                c_imgs = save_imgs('cuts/row_'+str(i)+'/blocks_'+str(j), char_imgs) # 如果要保存切图
                print(c_imgs)
        all_mark_boxs.append(row_char_boxs)
        all_char_imgs.append(row_char_imgs)


    return all_mark_boxs,all_char_imgs,img_o

最后返回的值是3个，all_mark_boxs是标记的字符位置的坐标集合。[左,上,右,下]是指某个字符在一张大图里的坐标，打印一下是这样的：

[[[[19, 26, 34, 53], [36, 26, 53, 53], [54, 26, 65, 53], [66, 26, 82, 53], [84, 26, 101, 53], [102, 26, 120, 53], [120, 26, 139, 53]], [[213, 26, 229, 53], [231, 26, 248, 53], [249, 26, 268, 53], [268, 26, 285, 53]], [[408, 26, 426, 53], [427, 26, 437, 53], [438, 26, 456, 53], [456, 26, 474, 53], [475, 26, 492, 53]]], [[[20, 76, 36, 102], [38, 76, 48, 102], [50, 76, 66, 102], [67, 76, 85, 102], [85, 76, 104, 102]], [[214, 76, 233, 102], [233, 76, 250, 102], [252, 76, 268, 102], [270, 76, 287, 102]], [[411, 76, 426, 102], [428, 76, 445, 102], [446, 76, 457, 102], [458, 76, 474, 102], [476, 76, 493, 102], [495, 76, 511, 102]]]]

它是有结构的。它的结构是：

all_char_imgs这个返回值，里面是上面坐标结构对应位置的图片。img_o就是原图了。

2.5 识别

循环，循环，还是TM循环！

对于识别，2.3 预测数据已经讲过了，那次是对于2张独立图片的识别，现在我们要对整张大图切分后的小图集合进行识别，这就又用到了循环。

翠花，上代码！

all_mark_boxs,all_char_imgs,img_o = divImg(path,save)
model = cnn.create_model()
model.load_weights('checkpoint/char_checkpoint')
class_name = np.load('class_name.npy')

# 遍历行
for i in range(0,len(all_char_imgs)):
    row_imgs = all_char_imgs[i]
    # 遍历块
    for j in range(0,len(row_imgs)):
        block_imgs = row_imgs[j]
        block_imgs = np.array(block_imgs)
        results = cnn.predict(model, block_imgs, class_name)
        print('recognize result:',results)

上面代码做的就是以块为单位，传递给神经网络进行预测，然后返回识别结果。

针对这张图，我们来进行裁剪和识别。

看底部的最后一行

recognize result: ['1', '0', '12', '2', '10']
recognize result: ['8', '12', '6', '10']
recognize result: ['1', '0', '12', '7', '10']

结果是索引，不是真实的字符，我们根据字典10: '=', 11: '+', 12: '-', 13: '×', 14: '÷'转换过来之后结果是：

recognize result: ['1', '0', '-', '2', '=']
recognize result: ['8', '-', '6', '=']
recognize result: ['1', '0', '-', '7', '=']

和图片是对应的：

2.6 计算并反馈

循环……

我们获取到了10-2=、8-6=2，也获取到了他们在原图的位置坐标[左,上,右,下]，那么怎么把结果反馈到原图上呢？

往往到这里就剩最后一步了。

再来温习一遍需求：作对了，能打对号；做错了，能打叉号；没做的，能补上答案。

实现分两步走：计算（是作对做错还是没错）和反馈（把预期结果写到原图上）。

2.6.1 计算 python有个函数很强大，就是eval函数，能计算字符串算式，比如直接计算eval("5+3-2")。

所以，一切都靠它了。

# 计算数值并返回结果  参数chars：['8', '-', '6', '=']
def calculation(chars):
    cstr = ''.join(chars)
    result = ''
    if("=" in cstr): # 有等号
        str_arr = cstr.split('=')
        c_str = str_arr[0]
        r_str = str_arr[1]
        c_str = c_str.replace("×","*")
        c_str = c_str.replace("÷","/") 
        try:
            c_r = int(eval(c_str))
        except Exception as e:
            print("Exception",e)

        if r_str == "":
            result = c_r
        else:
            if str(c_r) == str(r_str):
                result = "√"
            else:
                result = "×"

    return result

执行之后获得的结果是：

recognize result: ['8', '×', '4', '=']
calculate result: 32
recognize result: ['2', '-', '1', '=', '1']
calculate result: √
recognize result: ['1', '0', '-', '5', '=']
calculate result: 5

2.6.2 反馈

有了结果之后，把结果写到图片上，这是最后一步，也是最简单的一步。

但是实现起来，居然很繁琐。

得找坐标吧，得计算结果呈现的位置吧，我们还想标记不同的颜色，比如对了是绿色，错了是红色，补齐答案是灰色。

下面代码是在一个图img上，把文本内容text画到(left,top)位置，以特定颜色和大小。

# 绘制文本
def cv2ImgAddText(img, text, left, top, textColor=(255, 0, 0), textSize=20):
    if (isinstance(img, np.ndarray)):  # 判断是否OpenCV图片类型
        img = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
    # 创建一个可以在给定图像上绘图的对象
    draw = ImageDraw.Draw(img)
    # 字体的格式
    fontStyle = ImageFont.truetype("fonts/fangzheng_shusong.ttf", textSize, encoding="utf-8")
    # 绘制文本
    draw.text((left, top), text, textColor, font=fontStyle)
    # 转换回OpenCV格式
    return cv2.cvtColor(np.asarray(img), cv2.COLOR_RGB2BGR)

结合着切图的信息、计算的信息，下面代码提供思路参考：

# 获取切图标注，切图图片，原图图图片
all_mark_boxs,all_char_imgs,img_o = divImg(path,save)
# 恢复模型，用于图片识别
model = cnn.create_model()
model.load_weights('checkpoint/char_checkpoint')
class_name = np.load('class_name.npy')

# 遍历行
for i in range(0,len(all_char_imgs)):
    row_imgs = all_char_imgs[i]
    # 遍历块
    for j in range(0,len(row_imgs)):
        block_imgs = row_imgs[j]
        block_imgs = np.array(block_imgs)
        # 图片识别
        results = cnn.predict(model, block_imgs, class_name)
        print('recognize result:',results)
        # 计算结果
        result = calculation(results)
        print('calculate result:',result)
        # 获取块的标注坐标
        block_mark = all_mark_boxs[i][j]
        # 获取结果的坐标，写在块的最后一个字
        answer_box = block_mark[-1]
        # 计算最后一个字的位置
        x = answer_box[2] 
        y = answer_box[3]
        iw = answer_box[2] - answer_box[0]
        ih = answer_box[3] - answer_box[1]
        # 计算字体大小
        textSize =  max(iw,ih)
        # 根据结果设置字体颜色
        if str(result) == "√":
            color = (0, 255, 0)
        elif str(result) == "×":
            color = (255, 0, 0)
        else:
            color = (192, 192,192)
        # 将结果写到原图上
        img_o = cv2ImgAddText(img_o, str(result), answer_box[2],  answer_box[1],color, textSize)
# 将写满结果的原图保存
cv2.imwrite('result.jpg', img_o)

结果是下面这样的：

注意

1. 同级新建fonts文件夹里拷贝一些字体文件，从这里找C:\Windows\Fonts，几十个就行。

2. get_character_pic.py 生成字体

3. cnn.py 训练数据

4. main.py 裁剪指定图片并识别，素材图片新建imgs文件夹,在imgs/question.png下，结果文件保存在imgs/result.png。

5. 注意如果识别不成功，很可能是question.png的字体你没有训练（这幅图的字体是方正书宋简体，但是你只训练了楷体），这时候可以使用楷体自己编一个算式图。

原文：https://juejin.cn/post/7006732549451939847

一、亮出效果

最近一些软件的搜题、智能批改类的功能要下线。

退1024步讲，要不要自己做一个自动批改的功能啊？万一哪天孩子要用呢！

昨晚我做了一个梦，梦见我实现了这个功能，如下图所示：

功能简介：作对了，能打对号；做错了，能打叉号；没做的，能补上答案。

醒来后，我环顾四周，赶紧再躺下，希望梦还能接上。

二、实现步骤

基本思路

其实，搞定两点就成，第一是能识别数字，第二是能切分数字。

首先得能认识5是5，这是前提条件，其次是能找到5、6、7、8这些数字区域的位置。

前者是图像识别，后者是图像切割。

• 对于图像识别，一般的套路是下面这样的（CNN卷积神经网络）：

• 对于图像切割，一般的套路是下面的这样（横向纵向投影法）：

既然思路能走得通，那么咱们先搞图像识别。准备数据->训练数据并保存模型->使用训练模型预测结果。

2.1 准备数据

对于男友，找一个油嘴滑舌的花花公子，不如找一个闷葫芦IT男，亲手把他培养成你期望的样子。

咱们不用什么官方的mnist数据集，因为那是官方的，不是你的，你想要添加±×÷它也没有。

有些通用的数据集，虽然很强大，很方便，但是一旦放到你的场景中，效果一点也不如你的愿。

只有训练自己手里的数据，然后自己用起来才顺手。更重要的是，我们享受创造的过程。

假设，我们只给口算做识别，那么我们需要的图片数据有如下几类：

索引：0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
字符：0 1 2 3 4 5 6 7 8 9 = + - × ÷

如果能识别这些，基本上能满足整数的加减乘除运算了。

好了，图片哪里来？！

是啊，图片哪里来？

吓得我差点从梦里醒来，500万都规划好该怎么花了，居然双色球还没有选号！

梦里，一个老者跟我说，图片要自己生成。我问他如何生成，他呵呵一笑，消失在迷雾中……

仔细一想，其实也不难，打字我们总会吧，生成数字无非就是用代码把字写在图片上。

字之所以能展示，主要是因为有字体的支撑。

如果你用的是windows系统，那么打开KaTeX parse error: Undefined control sequence: \Windows at position 3: C:\̲W̲i̲n̲d̲o̲w̲s̲\Fonts这个文件夹，你会发现好多字体。

我们写代码调用这些字体，然后把它打印到一张图片上，是不是就有数据了。

而且这些数据完全是由我们控制的，想多就多，想少就少，想数字、字母、汉字、符号都可以，今天你搞出来数字识别，也就相当于你同时拥有了所有识别！想想还有点小激动呢！

看看，这就是打工和创业的区别。你用别人的数据相当于打工，你是不用操心，但是他给你什么你才有什么。自己造数据就相当于创业，虽然前期辛苦，你可以完全自己把握节奏，需要就加上，没用就去掉。

2.1.1 准备字体

建一个fonts文件夹，从字体库里拷一部分字体放进来，我这里是拷贝了13种字体文件。

好的，准备工作做好了，肯定很累吧，休息休息休息，一会儿再搞！

2.1.2 生成图片

代码如下，可以直接运行。

from __future__ import print_function
from PIL import Image
from PIL import ImageFont
from PIL import ImageDraw
import os
import shutil
import time

# %% 要生成的文本
label_dict = {0: '0', 1: '1', 2: '2', 3: '3', 4: '4', 5: '5', 6: '6', 7: '7', 8: '8', 9: '9', 10: '=', 11: '+', 12: '-', 13: '×', 14: '÷'}

# 文本对应的文件夹，给每一个分类建一个文件
for value,char in label_dict.items():
  train_images_dir = "dataset"+"/"+str(value)
  if os.path.isdir(train_images_dir):
      shutil.rmtree(train_images_dir)
  os.makedirs(train_images_dir)

# %% 生成图片
def makeImage(label_dict, font_path, width=24, height=24, rotate = 0):

  # 从字典中取出键值对
  for value,char in label_dict.items():
      # 创建一个黑色背景的图片，大小是24*24
      img = Image.new("RGB", (width, height), "black") 
      draw = ImageDraw.Draw(img)
      # 加载一种字体,字体大小是图片宽度的90%
      font = ImageFont.truetype(font_path, int(width*0.9))
      # 获取字体的宽高
      font_width, font_height = draw.textsize(char, font)
      # 计算字体绘制的x,y坐标，主要是让文字画在图标中心
      x = (width - font_width-font.getoffset(char)[0]) / 2
      y = (height - font_height-font.getoffset(char)[1]) / 2
      # 绘制图片，在那里画，画啥，什么颜色，什么字体
      draw.text((x,y), char, (255, 255, 255), font)
      # 设置图片倾斜角度
      img = img.rotate(rotate)
      # 命名文件保存，命名规则：dataset/编号/img-编号_r-选择角度_时间戳.png
      time_value = int(round(time.time() * 1000))
      img_path = "dataset/{}/img-{}_r-{}_{}.png".format(value,value,rotate,time_value)
      img.save(img_path)
       
# %% 存放字体的路径
font_dir = "./fonts"
for font_name in os.listdir(font_dir):
  # 把每种字体都取出来，每种字体都生成一批图片
  path_font_file = os.path.join(font_dir, font_name)
  # 倾斜角度从-10到10度，每个角度都生成一批图片
  for k in range(-10, 10, 1): 
      # 每个字符都生成图片
      makeImage(label_dict, path_font_file, rotate = k)

上面纯代码不到30行，相信大家应该能看懂！看不懂不是我的读者。

核心代码就是画文字。

draw.text((x,y), char, (255, 255, 255), font)

翻译一下就是：使用某字体在黑底图片的(x,y)位置写白色的char符号。

核心逻辑就是三层循环。

如果代码你运行的没有问题，最终会生成如下结果：

好了，数据准备好了。总共15个文件夹，每个文件夹下对应的各种字体各种倾斜角的字符图片3900个（字符15类×字体13种×角度20个），图片的大小是24×24像素。

有了数据，我们就可以再进行下一步了，下一步是训练和使用数据。

2.2 训练数据

2.2.1 构建模型

你先看代码，外行感觉好深奥，内行偷偷地笑。

# %% 导入必要的包 
import tensorflow as tf
import numpy as np
from tensorflow.keras import layers
from tensorflow.keras.models import Sequential
import pathlib
import cv2

# %% 构建模型
def create_model():
  model = Sequential([
      layers.experimental.preprocessing.Rescaling(1./255, input_shape=(24, 24, 1)),
      layers.Conv2D(24,3,activation='relu'),
      layers.MaxPooling2D((2,2)),
      layers.Conv2D(64,3, activation='relu'),
      layers.MaxPooling2D((2,2)),
      layers.Flatten(),
      layers.Dense(128, activation='relu'),
      layers.Dense(15)]
  )
   
  model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

  return model

这个模型的序列是下面这样的，作用是输入一个图片数据，经过各个层揉搓，最终预测出这个图片属于哪个分类。

这么多层都是干什么的，有什么用？和衣服一样，肯定是有用的，内衣、衬衣、毛衣、棉衣各有各的用处。

2.2.2 卷积层 Conv2D

各个职能部门的调查员，搜集和整理某单位区域内的特定数据。我们输入的是一个图像，它是由像素组成的，这就是R e s c a l i n g ( 1. / 255 , i n p u t s h a p e = ( 24 , 24 , 1 ) ) Rescaling(1./255, input_shape=(24, 24, 1))Rescaling(1./255,input shape=(24,24,1))中，input_shape输入形状是24*24像素1个通道（彩色是RGB 3个通道）的图像。

卷积层代码中的定义是Conv2D(24,3),意思是用3*3像素的卷积核，去提取24个特征。

我把图转到地图上来，你就能理解了。以我大济南的市中区为例子。

卷积的作用就相当于从地图的某级单位区域中收集多组特定信息。比如以小区为单位去提取住宅数量、车位数量、学校数量、人口数、年收入、学历、年龄等等24个维度的信息。小区相当于卷积核。

提取完成之后是这样的。

第一次卷积之后，我们从市中区得到N个小区的数据。

卷积是可以进行多次的。

比如在小区卷积之后，我们还可在小区的基础上再来一次卷积，在卷积就是街道了。

通过再次以街道为单位卷积小区，我们就从市中区得到了N个街道的数据。

这就是卷积的作用。

通过一次次卷积，就把一张大图，通过特定的方法卷起来，最终留下来的是固定几组有目的数据，以此方便后续的评选决策。这是评选一个区的数据，要是评选济南市，甚至山东省，也是这么卷积。这和现实生活中评选文明城市、经济强省也是一个道理。

2.2.3 池化层 MaxPooling2D

说白了就是四舍五入。

计算机的计算能力是强大的，比你我快，但也不是不用考虑成本。我们当然希望它越快越好，如果一个方法能省一半的时间，我们肯定愿意用这种方法。

池化层干的就是这个事情。池化的代码定义是这样的M a x P o o l i n g 2 D ( ( 2 , 2 ) ) MaxPooling2D((2,2))MaxPooling2D((2,2))，这里是最大值池化。其中（2,2）是池化层的大小，其实就是在2*2的区域内，我们认为这一片可以合成一个单位。

再以地图举个例子，比如下面的16个格子里的数据，是16个街道的学校数量。

为了进一步提高计算效率，少计算一些数据，我们用2*2的池化层进行池化。

池化的方格是4个街道合成1个，新单位学校数量取成员中学校数量最大（也有取最小，取平均多种池化）的那一个。池化之后，16个格子就变为了4个格子，从而减少了数据。

这就是池化层的作用。

2.2.4 全连接层 Dense

弱水三千，只取一瓢。

在这里，它其实是一个分类器。

我们构建它时，代码是这样的D e n s e ( 15 ) Dense(15)Dense(15)。

它所做的事情，不管你前面是怎么样，有多少维度，到我这里我要强行转化为固定的通道。

比如识别字母a~z，我有500个神经元参与判断，但是最终输出结果就是26个通道(a,b,c,……,y,z)。

我们这里总共有15类字符，所以是15个通道。给定一个输入后，输出为每个分类的概率。

注意：上面都是二维的输入，比如24×24，但是全连接层是一维的，所以代码中使用了l a y e r s . F l a t t e n ( ) layers.Flatten()layers.Flatten()将二维数据拉平为一维数据([[11,12],[21,22]]->[11,12,21,22])。

对于总体的模型，调用m o d e l . s u m m a r y ( ) model.summary()model.summary()打印序列的网络结构如下：

_________________________________________________________________
Layer (type)                 Output Shape             Param #   
=================================================================
rescaling_2 (Rescaling)     (None, 24, 24, 1)         0         
_________________________________________________________________
conv2d_4 (Conv2D)           (None, 22, 22, 24)       240       
_________________________________________________________________
max_pooling2d_4 (MaxPooling2 (None, 11, 11, 24)       0         
_________________________________________________________________
conv2d_5 (Conv2D)           (None, 9, 9, 64)         13888     
_________________________________________________________________
max_pooling2d_5 (MaxPooling2 (None, 4, 4, 64)         0         
_________________________________________________________________
flatten_2 (Flatten)         (None, 1024)             0         
_________________________________________________________________
dense_4 (Dense)             (None, 128)               131200    
_________________________________________________________________
dense_5 (Dense)             (None, 15)               1935      
=================================================================
Total params: 147,263
Trainable params: 147,263
Non-trainable params: 0
_________________________________________________________________

我们看到conv2d_5 (Conv2D) (None, 9, 9, 64) 经过2*2的池化之后变为max_pooling2d_5 (MaxPooling2 (None, 4, 4, 64)。(None, 4, 4, 64) 再经过F l a t t e n FlattenFlatten拉成一维之后变为(None, 1024)，经过全连接变为(None, 128)再一次全连接变为(None, 15)，15就是我们的最终分类。这一切都是我们设计的。

m o d e l . c o m p i l e model.compilemodel.compile就是配置模型的几个参数，这个现阶段记住就可以。

2.2.5 训练数据

执行就完了。

# 统计文件夹下的所有图片数量
data_dir = pathlib.Path('dataset')
# 从文件夹下读取图片，生成数据集
train_ds = tf.keras.preprocessing.image_dataset_from_directory(
  data_dir, # 从哪个文件获取数据
  color_mode="grayscale", # 获取数据的颜色为灰度
  image_size=(24, 24), # 图片的大小尺寸
  batch_size=32 # 多少个图片为一个批次
)
# 数据集的分类，对应dataset文件夹下有多少图片分类
class_names = train_ds.class_names
# 保存数据集分类
np.save("class_name.npy", class_names)
# 数据集缓存处理
AUTOTUNE = tf.data.experimental.AUTOTUNE
train_ds = train_ds.cache().shuffle(1000).prefetch(buffer_size=AUTOTUNE)
# 创建模型
model = create_model()
# 训练模型，epochs=10，所有数据集训练10遍
model.fit(train_ds,epochs=10)
# 保存训练后的权重
model.save_weights('checkpoint/char_checkpoint')

执行之后会输出如下信息：

Found 3900 files belonging to 15 classes. 
Epoch 1/10 122/122 [=========] - 2s 19ms/step - loss: 0.5795 - accuracy: 0.8615 
Epoch 2/10 122/122 [=========] - 2s 18ms/step - loss: 0.0100 - accuracy: 0.9992 
Epoch 3/10 122/122 [=========] - 2s 19ms/step - loss: 0.0027 - accuracy: 1.0000 
Epoch 4/10 122/122 [=========] - 2s 19ms/step - loss: 0.0013 - accuracy: 1.0000 
Epoch 5/10 122/122 [=========] - 2s 20ms/step - loss: 8.4216e-04 - accuracy: 1.0000 
Epoch 6/10 122/122 [=========] - 2s 18ms/step - loss: 5.5273e-04 - accuracy: 1.0000 
Epoch 7/10 122/122 [=========] - 3s 21ms/step - loss: 4.0966e-04 - accuracy: 1.0000 
Epoch 8/10 122/122 [=========] - 2s 20ms/step - loss: 3.0308e-04 - accuracy: 1.0000 
Epoch 9/10 122/122 [=========] - 3s 23ms/step - loss: 2.3446e-04 - accuracy: 1.0000 
Epoch 10/10 122/122 [=========] - 3s 21ms/step - loss: 1.8971e-04 - accuracy: 1.0000

我们看到，第3遍时候，准确率达到100%了。最后结束的时候，我们发现文件夹checkpoint下多了几个文件：

char_checkpoint.data-00000-of-00001
char_checkpoint.index
checkpoint

上面那几个文件是训练结果，训练保存之后就不用动了。后面可以直接用这些数据进行预测。

2.3 预测数据

终于到了享受成果的时候了。

# 设置待识别的图片
img1=cv2.imread('img1.png',0) 
img2=cv2.imread('img2.png',0) 
imgs = np.array([img1,img2])
# 构建模型
model = create_model()
# 加载前期训练好的权重
model.load_weights('checkpoint/char_checkpoint')
# 读出图片分类
class_name = np.load('class_name.npy')
# 预测图片，获取预测值
predicts = model.predict(imgs) 
results = [] # 保存结果的数组
for predict in predicts: #遍历每一个预测结果
  index = np.argmax(predict) # 寻找最大值
  result = class_name[index] # 取出字符
  results.append(result)
print(results)

我们找两张图片img1.png,img2.png，一张是数字6，一张是数字8，两张图放到代码同级目录下，验证一下识别效果如何。

图片要通过cv2.imread('img1.png',0) 转化为二维数组结构，0参数是灰度图片。经过处理后，图片转成的数组是如下所示(24,24)的结构：

我们要同时验证两张图，所以把两张图再组成imgs放到一起，imgs的结构是（2,24,24）。

下面是构建模型，然后加载权重。通过调用predicts = model.predict(imgs)将imgs传递给模型进行预测得出predicts。

predicts的结构是(2,15),数值如下面所示：

[[ 16.134243 -12.10675 -1.1994154 -27.766754 -43.4324 -9.633694 -12.214878 1.6287893 2.562174 3.2222707 13.834648 28.254173 -6.102874 16.76582 7.2586184] [ 5.022571 -8.762314 -6.7466817 -23.494259 -30.170597 2.4392672 -14.676962 5.8255725 8.855118 -2.0998626 6.820853 7.6578817 1.5132296 24.4664 2.4192357]]

意思是有2个预测结果，每一个图片的预测结果有15种可能。

然后根据 index = np.argmax(predict) 找出最大可能的索引。

根据索引找到字符的数值结果是[‘6’, ‘8’]。

下面是数据在内存中的监控：

可见，我们的预测是准确的。

下面，我们将要把图片中数字切割出来，进行识别了。

之前我们准备了数据，训练了数据，并且拿图片进行了识别，识别结果正确。

到目前为止，看来问题不大……没有大问题，有问题也大不了。

下面就是把图片进行切割识别了。

下面这张大图片，怎么把它搞一搞，搞成单个小数字的图片。

续：写了个自动批改小孩作业的代码（下）

原文：https://juejin.cn/post/7006732549451939847

参考链接：

https://mp.weixin.qq.com/s/Umq6UjeKD0kwgyZgVA28zA

https://weibo.com/5044281310/LbhRgewXz

    整理 | 王晓曼

今天准备爬取某某点评店铺信息时，遇到了『字体』反爬。比如这样的：

还有这样的：

可以看到这些字体已经被加密（反爬）

竟然遇到这种情况，那辰哥就带大家如何去解决这类反爬（字体反爬类）

01 网页分析

在开始分析反爬之前，先简单的介绍一下背景（爬取的网页）

辰哥爬取的某某点评的店铺信息。一开始查看网页源码是这样的

这种什么也看不到，咱们换另一种方式：通过程序直接把整个网页源代码保存下来

获取到的网页源码如下：

比如这里看到评论数（4位数）都有对应着一个编号（相同的数字编号相同），应该是对应着网站的字体库。

下一步，我们需要找到这个网站的字体库。

02 获取字体库

这里的字体库建议在目标网站里面去获取，因为不同的网站的字体库是不一样，导致解码还原的字体也会不一样。

1、抓包获取字体库

在浏览器network里面可以看到一共有三种字体库。（三种字体库各有不同的妙用，后面会有解释）

把字体库链接复制在浏览器里面打开，就可以把字体库下载到本地。

2、查看字体库

这里使用FontCreator的工具查看字体库。

下载地址：

https://www.high-logic.com/font-editor/fontcreator/download

这里需要注册，邮箱验证才能下载，不过辰哥已经下载了，可以在公众号回复：FC，获取安装包。

安装之后，把刚刚下载的字体库在FontCreator中打开

可以看到字体的内容以及对应的编号。

比如数字7对应F399、数字8对应F572 ，咱们在原网页和源码对比，是否如此？？？

可以看到，真是一模一样对应着解码就可以还原字体。

3、为什么会有三个字体库

在查看加密字体的CSS样式时，方式有css内容是这样的

字体库1：d35c3812.woff 对应解码class为 shopNum

字体库2：084c9fff.woff 对应解码class为 reviewTag和address

字体库3：73f5e6f3.woff 对应解码class为 tagName

也就是说，字体所属的不同class标签，对应的解密字体库是不一样的，辰哥这里不得不说一句：太鸡贼了

咱们这里获取的评论数，clas为shopNum，需要用到字体库d35c3812.woff

03 代码实现解密

1、加载字体库

既然我们已经知道了字体反爬的原理，那么我们就可以开始编程实现解密还原。

加载字体库的Python库包是：fontTools ，安装命令如下：

pip install fontTools

将字体库的内容对应关系保存为xml格式

code和name是一一对应关系

可以看到网页源码中的编号后四位对应着字体库的编号。

因此我们可以建立应该字体对应集合

建立好映射关系好，到网页源码中去进行替换

这样我们就成功的将字体反爬处理完毕。后面提取内容大家基本都没问题。

2、完整代码

输出结果：

可以看到加密的数字全部都还原了。

04 小结

辰哥在本文中主要讲解了如此处理字体反爬问题，并以某某点评为例去实战演示分析。辰哥在文中处理的数字类型，大家可以尝试去试试中文如何解决。

作者：Python研究者
来源：https://juejin.cn/post/6970933428145356831

1、迭代

1.1 迭代的概念

使用for循环遍历取值的过程叫做迭代，比如：使用for循环遍历列表获取值的过程

# Python 中的迭代
for value in [2, 3, 4]:
    print(value)

1.2 可迭代对象

标准概念：在类里面定义__iter__方法，并使用该类创建的对象就是可迭代对象

简单记忆：使用for循环遍历取值的对象叫做可迭代对象, 比如：列表、元组、字典、集合、range、字符串

1.3 判断对象是否是可迭代对象

# 元组，列表，字典，字符串，集合，range都是可迭代对象
from collections import Iterable
# 如果解释器提示警告，就是用下面的导入方式
# from collections.abc import Iterable

# 判断对象是否是指定类型
result = isinstance((3, 5), Iterable)
print("元组是否是可迭代对象:", result)

result = isinstance([3, 5], Iterable)
print("列表是否是可迭代对象:", result)

result = isinstance({"name": "张三"}, Iterable)
print("字典是否是可迭代对象:", result)

result = isinstance("hello", Iterable)
print("字符串是否是可迭代对象:", result)

result = isinstance({3, 5}, Iterable)
print("集合是否是可迭代对象:", result)

result = isinstance(range(5), Iterable)
print("range是否是可迭代对象:", result)

result = isinstance(5, Iterable)
print("整数是否是可迭代对象:", result)

# 提示: 以后还根据对象判断是否是其它类型，比如以后可以判断函数里面的参数是否是自己想要的类型
result = isinstance(5, int)
print("整数是否是int类型对象:", result)

class Student(object):
    pass

stu = Student()
result = isinstance(stu, Iterable)

print("stu是否是可迭代对象:", result)

result = isinstance(stu, Student)

print("stu是否是Student类型的对象:", result)

1.4 自定义可迭代对象

在类中实现__iter__方法

自定义可迭代类型代码

from collections import Iterable
# 如果解释器提示警告，就是用下面的导入方式
# from collections.abc import Iterable

# 自定义可迭代对象: 在类里面定义__iter__方法创建的对象就是可迭代对象
class MyList(object):

    def __init__(self):
        self.my_list = list()

    # 添加指定元素
    def append_item(self, item):
        self.my_list.append(item)

    def __iter__(self):
        # 可迭代对象的本质：遍历可迭代对象的时候其实获取的是可迭代对象的迭代器， 然后通过迭代器获取对象中的数据
        pass

my_list = MyList()
my_list.append_item(1)
my_list.append_item(2)
result = isinstance(my_list, Iterable)

print(result)

for value in my_list:
    print(value)

执行结果:

Traceback (most recent call last):
True
  File "/Users/hbin/Desktop/untitled/aa.py", line 24, in <module>
    for value in my_list:
TypeError: iter() returned non-iterator of type 'NoneType'

通过执行结果可以看出来，遍历可迭代对象依次获取数据需要迭代器

总结

在类里面提供一个__iter__创建的对象是可迭代对象，可迭代对象是需要迭代器完成数据迭代的

2、迭代器

2.1 自定义迭代器对象

自定义迭代器对象: 在类里面定义__iter__和__next__方法创建的对象就是迭代器对象

from collections import Iterable
from collections import Iterator

# 自定义可迭代对象: 在类里面定义__iter__方法创建的对象就是可迭代对象
class MyList(object):

    def __init__(self):
        self.my_list = list()

    # 添加指定元素
    def append_item(self, item):
        self.my_list.append(item)

    def __iter__(self):
        # 可迭代对象的本质：遍历可迭代对象的时候其实获取的是可迭代对象的迭代器， 然后通过迭代器获取对象中的数据
        my_iterator = MyIterator(self.my_list)
        return my_iterator


# 自定义迭代器对象: 在类里面定义__iter__和__next__方法创建的对象就是迭代器对象
class MyIterator(object):

    def __init__(self, my_list):
        self.my_list = my_list

        # 记录当前获取数据的下标
        self.current_index = 0

        # 判断当前对象是否是迭代器
        result = isinstance(self, Iterator)
        print("MyIterator创建的对象是否是迭代器:", result)

    def __iter__(self):
        return self

    # 获取迭代器中下一个值
    def __next__(self):
        if self.current_index < len(self.my_list):
            self.current_index += 1
            return self.my_list[self.current_index - 1]
        else:
            # 数据取完了，需要抛出一个停止迭代的异常
            raise StopIteration


my_list = MyList()
my_list.append_item(1)
my_list.append_item(2)
result = isinstance(my_list, Iterable)

print(result)

for value in my_list:
    print(value)

运行结果:

True
MyIterator创建的对象是否是迭代器: True
1
2

2.2 iter()函数与next()函数

1. iter函数: 获取可迭代对象的迭代器，会调用可迭代对象身上的__iter__方法

2. next函数: 获取迭代器中下一个值，会调用迭代器对象身上的__next__方法

# 自定义可迭代对象: 在类里面定义__iter__方法创建的对象就是可迭代对象
class MyList(object):

    def __init__(self):
        self.my_list = list()

    # 添加指定元素
    def append_item(self, item):
        self.my_list.append(item)

    def __iter__(self):
        # 可迭代对象的本质：遍历可迭代对象的时候其实获取的是可迭代对象的迭代器， 然后通过迭代器获取对象中的数据
        my_iterator = MyIterator(self.my_list)
        return my_iterator


# 自定义迭代器对象: 在类里面定义__iter__和__next__方法创建的对象就是迭代器对象
# 迭代器是记录当前数据的位置以便获取下一个位置的值
class MyIterator(object):

    def __init__(self, my_list):
        self.my_list = my_list

        # 记录当前获取数据的下标
        self.current_index = 0

    def __iter__(self):
        return self

    # 获取迭代器中下一个值
    def __next__(self):
        if self.current_index < len(self.my_list):
            self.current_index += 1
            return self.my_list[self.current_index - 1]
        else:
            # 数据取完了，需要抛出一个停止迭代的异常
            raise StopIteration

# 创建了一个自定义的可迭代对象
my_list = MyList()
my_list.append_item(1)
my_list.append_item(2)

# 获取可迭代对象的迭代器
my_iterator = iter(my_list)
print(my_iterator)
# 获取迭代器中下一个值
# value = next(my_iterator)
# print(value)

# 循环通过迭代器获取数据
while True:
    try:
        value = next(my_iterator)
        print(value)
    except StopIteration as e:
        break

2.3 for循环的本质

遍历的是可迭代对象

• for item in Iterable 循环的本质就是先通过iter()函数获取可迭代对象Iterable的迭代器，然后对获取到的迭代器不断调用next()方法来获取下一个值并将其赋值给item，当遇到StopIteration的异常后循环结束。

遍历的是迭代器

• for item in Iterator 循环的迭代器，不断调用next()方法来获取下一个值并将其赋值给item，当遇到StopIteration的异常后循环结束。

2.4 迭代器的应用场景

我们发现迭代器最核心的功能就是可以通过next()函数的调用来返回下一个数据值。如果每次返回的数据值不是在一个已有的数据集合中读取的，而是通过程序按照一定的规律计算生成的，那么也就意味着可以不用再依赖一个已有的数据集合，也就是说不用再将所有要迭代的数据都一次性缓存下来供后续依次读取，这样可以节省大量的存储（内存）空间。

举个例子，比如，数学中有个著名的斐波拉契数列（Fibonacci），数列中第一个数为0，第二个数为1，其后的每一个数都可由前两个数相加得到：

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ...

现在我们想要通过for...in...循环来遍历迭代斐波那契数列中的前n个数。那么这个斐波那契数列我们就可以用迭代器来实现，每次迭代都通过数学计算来生成下一个数。

class Fibonacci(object):

    def __init__(self, num):
        # num:表示生成多少fibonacci数字
        self.num = num
        # 记录fibonacci前两个值
        self.a = 0
        self.b = 1
        # 记录当前生成数字的索引
        self.current_index = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.current_index < self.num:
            result = self.a
            self.a, self.b = self.b, self.a + self.b
            self.current_index += 1
            return result
        else:
            raise StopIteration


fib = Fibonacci(5)
# value = next(fib)
# print(value)

for value in fib:
    print(value)

执行结果:

0
1
1
2
3

小结

迭代器的作用就是是记录当前数据的位置以便获取下一个位置的值

3、生成器

3.1 生成器的概念

生成器是一类特殊的迭代器,它不需要再像上面的类一样写__iter__()和__next__()方法了, 使用更加方便,它依然可以使用next函数和for循环取值

3.2 创建生成器方法1

• 第一种方法很简单，只要把一个列表生成式的 [ ] 改成 ( )

my_list = [i * 2 for i in range(5)]
print(my_list)

# 创建生成器
my_generator = (i * 2 for i in range(5))
print(my_generator)

# next获取生成器下一个值
# value = next(my_generator)
#
# print(value)
for value in my_generator:
    print(value)

执行结果:

[0, 2, 4, 6, 8]

<generator object <genexpr> at 0x101367048>

0

2

4

6

8

3.3 创建生成器方法2

在def函数里面看到有yield关键字那么就是生成器

def fibonacci(num):
    a = 0
    b = 1
    # 记录生成fibonacci数字的下标
    current_index = 0
    print("--11---")
    while current_index < num:
        result = a
        a, b = b, a + b
        current_index += 1
        print("--22---")
        # 代码执行到yield会暂停，然后把结果返回出去，下次启动生成器会在暂停的位置继续往下执行
        yield result
        print("--33---")


fib = fibonacci(5)
value = next(fib)
print(value)
value = next(fib)
print(value)

value = next(fib)
print(value)

# for value in fib:
#     print(value)

在使用生成器实现的方式中，我们将原本在迭代器__next__方法中实现的基本逻辑放到一个函数中来实现，但是将每次迭代返回数值的return换成了yield，此时新定义的函数便不再是函数，而是一个生成器了。

简单来说：只要在def中有yield关键字的 就称为 生成器

3.4 生成器使用return关键字

def fibonacci(num):

    a = 0

    b = 1

    # 记录生成fibonacci数字的下标

    current_index = 0

    print("--11---")

    while current_index < num:

        result = a

        a, b = b, a + b

        current_index += 1

        print("--22---")

        # 代码执行到yield会暂停，然后把结果返回出去，下次启动生成器会在暂停的位置继续往下执行

        yield result

        print("--33---")

        return "嘻嘻"



fib = fibonacci(5)

value = next(fib)

print(value)

# 提示： 生成器里面使用return关键字语法上没有问题，但是代码执行到return语句会停止迭代，抛出停止迭代异常



# return 和 yield的区别

# yield: 每次启动生成器都会返回一个值，多次启动可以返回多个值，也就是yield可以返回多个值

# return: 只能返回一次值，代码执行到return语句就停止迭代



try:

    value = next(fib)

    print(value)

except StopIteration as e:

    # 获取return的返回值

    print(e.value)

提示:

• 生成器里面使用return关键字语法上没有问题，但是代码执行到return语句会停止迭代，抛出停止迭代异常

3.5 yield和return的对比

• 使用了yield关键字的函数不再是函数，而是生成器。（使用了yield的函数就是生成器）

• 代码执行到yield会暂停，然后把结果返回出去，下次启动生成器会在暂停的位置继续往下执行

• 每次启动生成器都会返回一个值，多次启动可以返回多个值，也就是yield可以返回多个值

• return只能返回一次值，代码执行到return语句就停止迭代,抛出停止迭代异常

3.6 使用send方法启动生成器并传参

send方法启动生成器的时候可以传参数

def gen():
    i = 0
    while i<5:
        temp = yield i
        print(temp)
        i+=1
 

执行结果:

In [43]: f = gen()

In [44]: next(f)
Out[44]: 0

In [45]: f.send('haha')
haha
Out[45]: 1

In [46]: next(f)
None
Out[46]: 2

In [47]: f.send('haha')
haha
Out[47]: 3

In [48]:

**注意:如果第一次启动生成器使用send方法，那么参数只能传入None,一般第一次启动生成器使用next函数

小结

• 生成器创建有两种方式，一般都使用yield关键字方法创建生成器

• yield特点是代码执行到yield会暂停，把结果返回出去，再次启动生成器在暂停的位置继续往下执行

4、协程

4.1 协程的概念

协程，又称微线程，纤程,也称为用户级线程，在不开辟线程的基础上完成多任务，也就是在单线程的情况下完成多任务，多个任务按照一定顺序交替执行 通俗理解只要在def里面只看到一个yield关键字表示就是协程

协程是也是实现多任务的一种方式

协程yield的代码实现

简单实现协程

import time

def work1():
    while True:
        print("----work1---")
        yield
        time.sleep(0.5)

def work2():
    while True:
        print("----work2---")
        yield
        time.sleep(0.5)

def main():
    w1 = work1()
    w2 = work2()
    while True:
        next(w1)
        next(w2)

if __name__ == "__main__":
    main()

运行结果：

----work1---
----work2---
----work1---
----work2---
----work1---
----work2---
----work1---
----work2---
----work1---
----work2---
----work1---
----work2---
...省略...

小结

协程之间执行任务按照一定顺序交替执行

5、greenlet

5.1 greentlet的介绍

为了更好使用协程来完成多任务，python中的greenlet模块对其封装，从而使得切换任务变的更加简单

使用如下命令安装greenlet模块:

pip3 install greenlet

使用协程完成多任务

import time

import greenlet





# 任务1

def work1():

    for i in range(5):

        print("work1...")

        time.sleep(0.2)

        # 切换到协程2里面执行对应的任务

        g2.switch()





# 任务2

def work2():

    for i in range(5):

        print("work2...")

        time.sleep(0.2)

        # 切换到第一个协程执行对应的任务

        g1.switch()





if __name__ == '__main__':

    # 创建协程指定对应的任务

    g1 = greenlet.greenlet(work1)

    g2 = greenlet.greenlet(work2)



    # 切换到第一个协程执行对应的任务

    g1.switch()

运行效果

work1...
work2...
work1...
work2...
work1...
work2...
work1...
work2...
work1...
work2...

6、gevent

6.1 gevent的介绍

greenlet已经实现了协程，但是这个还要人工切换，这里介绍一个比greenlet更强大而且能够自动切换任务的第三方库，那就是gevent。

gevent内部封装的greenlet，其原理是当一个greenlet遇到IO(指的是input output 输入输出，比如网络、文件操作等)操作时，比如访问网络，就自动切换到其他的greenlet，等到IO操作完成，再在适当的时候切换回来继续执行。

由于IO操作非常耗时，经常使程序处于等待状态，有了gevent为我们自动切换协程，就保证总有greenlet在运行，而不是等待IO

安装

pip3 install gevent

6.2 gevent的使用

import gevent

def work(n):
    for i in range(n):
        # 获取当前协程
        print(gevent.getcurrent(), i)

g1 = gevent.spawn(work, 5)
g2 = gevent.spawn(work, 5)
g3 = gevent.spawn(work, 5)
g1.join()
g2.join()
g3.join()

运行结果

<Greenlet "Greenlet-0" at 0x26d8c970488: work(5)> 0

<Greenlet "Greenlet-1" at 0x26d8c970598: work(5)> 0

<Greenlet "Greenlet-2" at 0x26d8c9706a8: work(5)> 0

<Greenlet "Greenlet-0" at 0x26d8c970488: work(5)> 1

<Greenlet "Greenlet-1" at 0x26d8c970598: work(5)> 1

<Greenlet "Greenlet-2" at 0x26d8c9706a8: work(5)> 1

<Greenlet "Greenlet-0" at 0x26d8c970488: work(5)> 2

<Greenlet "Greenlet-1" at 0x26d8c970598: work(5)> 2

<Greenlet "Greenlet-2" at 0x26d8c9706a8: work(5)> 2

<Greenlet "Greenlet-0" at 0x26d8c970488: work(5)> 3

<Greenlet "Greenlet-1" at 0x26d8c970598: work(5)> 3

<Greenlet "Greenlet-2" at 0x26d8c9706a8: work(5)> 3

<Greenlet "Greenlet-0" at 0x26d8c970488: work(5)> 4

<Greenlet "Greenlet-1" at 0x26d8c970598: work(5)> 4

<Greenlet "Greenlet-2" at 0x26d8c9706a8: work(5)> 4

可以看到，3个greenlet是依次运行而不是交替运行

6.3 gevent切换执行

import gevent

def work(n):
    for i in range(n):
        # 获取当前协程
        print(gevent.getcurrent(), i)
        #用来模拟一个耗时操作，注意不是time模块中的sleep
        gevent.sleep(1)

g1 = gevent.spawn(work, 5)
g2 = gevent.spawn(work, 5)
g3 = gevent.spawn(work, 5)
g1.join()
g2.join()
g3.join()

运行结果

<Greenlet at 0x7fa70ffa1c30: f(5)> 0
<Greenlet at 0x7fa70ffa1870: f(5)> 0
<Greenlet at 0x7fa70ffa1eb0: f(5)> 0
<Greenlet at 0x7fa70ffa1c30: f(5)> 1
<Greenlet at 0x7fa70ffa1870: f(5)> 1
<Greenlet at 0x7fa70ffa1eb0: f(5)> 1
<Greenlet at 0x7fa70ffa1c30: f(5)> 2
<Greenlet at 0x7fa70ffa1870: f(5)> 2
<Greenlet at 0x7fa70ffa1eb0: f(5)> 2
<Greenlet at 0x7fa70ffa1c30: f(5)> 3
<Greenlet at 0x7fa70ffa1870: f(5)> 3
<Greenlet at 0x7fa70ffa1eb0: f(5)> 3
<Greenlet at 0x7fa70ffa1c30: f(5)> 4
<Greenlet at 0x7fa70ffa1870: f(5)> 4
<Greenlet at 0x7fa70ffa1eb0: f(5)> 4

6.4 给程序打补丁

import gevent
import time
from gevent import monkey

# 打补丁，让gevent框架识别耗时操作，比如：time.sleep，网络请求延时
monkey.patch_all()


# 任务1
def work1(num):
    for i in range(num):
        print("work1....")
        time.sleep(0.2)
        # gevent.sleep(0.2)

# 任务1
def work2(num):
    for i in range(num):
        print("work2....")
        time.sleep(0.2)
        # gevent.sleep(0.2)



if __name__ == '__main__':
    # 创建协程指定对应的任务
    g1 = gevent.spawn(work1, 3)
    g2 = gevent.spawn(work2, 3)

    # 主线程等待协程执行完成以后程序再退出
    g1.join()
    g2.join()

运行结果

work1....
work2....
work1....
work2....
work1....
work2....

6.5 注意

• 当前程序是一个死循环并且还能有耗时操作，就不需要加上join方法了,因为程序需要一直运行不会退出

示例代码

import gevent
import time
from gevent import monkey

# 打补丁，让gevent框架识别耗时操作，比如：time.sleep，网络请求延时
monkey.patch_all()


# 任务1
def work1(num):
    for i in range(num):
        print("work1....")
        time.sleep(0.2)
        # gevent.sleep(0.2)

# 任务1
def work2(num):
    for i in range(num):
        print("work2....")
        time.sleep(0.2)
        # gevent.sleep(0.2)



if __name__ == '__main__':
    # 创建协程指定对应的任务
    g1 = gevent.spawn(work1, 3)
    g2 = gevent.spawn(work2, 3)

    while True:
        print("主线程中执行")
        time.sleep(0.5)

执行结果:

主线程中执行work1....work2....work1....work2....work1....work2....主线程中执行主线程中执行主线程中执行..省略..

• 如果使用的协程过多，如果想启动它们就需要一个一个的去使用join()方法去阻塞主线程，这样代码会过于冗余，可以使用gevent.joinall()方法启动需要使用的协程

  实例代码

 import time
import gevent

def work1():
    for i in range(5):
        print("work1工作了{}".format(i))
        gevent.sleep(1)

def work2():
    for i in range(5):
        print("work2工作了{}".format(i))
        gevent.sleep(1)


if __name__ == '__main__':
    w1 = gevent.spawn(work1)
    w2 = gevent.spawn(work2)
    gevent.joinall([w1, w2])  # 参数可以为list，set或者tuple

7、进程、线程、协程对比

7.1 进程、线程、协程之间的关系

• 一个进程至少有一个线程，进程里面可以有多个线程

• 一个线程里面可以有多个协程

7.2 进程、线程、线程的对比

1. 进程是资源分配的单位

2. 线程是操作系统调度的单位

3. 进程切换需要的资源最大，效率很低

4. 线程切换需要的资源一般，效率一般（当然了在不考虑GIL的情况下）

5. 协程切换任务资源很小，效率高

6. 多进程、多线程根据cpu核数不一样可能是并行的，但是协程是在一个线程中 所以是并发

小结

• 进程、线程、协程都是可以完成多任务的，可以根据自己实际开发的需要选择使用

• 由于线程、协程需要的资源很少，所以使用线程和协程的几率最大

• 开辟协程需要的资源最少

作者：y大壮
来源：https://juejin.cn/post/6971037591952949256

事情是这样的

正准备下班的python开发小哥哥

接到女朋友今晚要加班的电话

并给他发来一张背景模糊的自拍照

如下 ↓ ↓ ↓

敏感的小哥哥心生疑窦，难道会有原谅帽
然后python撸了一段代码 分析照片

分析下来 emmm
拍摄地址居然在 XXX酒店

小哥哥崩溃之余 大呼上当

python分析照片

小哥哥将发给自己的照片原图下载下来
并使用python写了一个脚本
读取到了照片拍摄的详细的地址
详细到了具体的街道和酒店名称

引入exifread模块

首先安装python的exifread模块，用于照片分析
pip install exifread 安装exfriead模块

PS C:\WINDOWS\system32> pip install exifread
Collecting exifread
  Downloading ExifRead-2.3.2-py3-none-any.whl (38 kB)
Installing collected packages: exifread
Successfully installed exifread-2.3.2
PS C:\WINDOWS\system32> pip install json

GPS经纬度信息

其实我们平时拍摄的照片里，隐藏了大量的私密信息
包括 拍摄时间、极其精确 具体的GPS信息。
下面是通过exifread模块，来读取照片内的经纬度信息。

#读取照片的GPS经纬度信息
def find_GPS_image(pic_path):
  GPS = {}
  date = ''
  with open(pic_path, 'rb') as f:
      tags = exifread.process_file(f)
      for tag, value in tags.items():
          #纬度
          if re.match('GPS GPSLatitudeRef', tag):
              GPS['GPSLatitudeRef'] = str(value)
          #经度
          elif re.match('GPS GPSLongitudeRef', tag):
              GPS['GPSLongitudeRef'] = str(value)
          #海拔
          elif re.match('GPS GPSAltitudeRef', tag):
              GPS['GPSAltitudeRef'] = str(value)
          elif re.match('GPS GPSLatitude', tag):
              try:
                  match_result = re.match('\[(\w*),(\w*),(\w.*)/(\w.*)\]', str(value)).groups()
                  GPS['GPSLatitude'] = int(match_result[0]), int(match_result[1]), int(match_result[2])
              except:
                  deg, min, sec = [x.replace(' ', '') for x in str(value)[1:-1].split(',')]
                  GPS['GPSLatitude'] = latitude_and_longitude_convert_to_decimal_system(deg, min, sec)
          elif re.match('GPS GPSLongitude', tag):
              try:
                  match_result = re.match('\[(\w*),(\w*),(\w.*)/(\w.*)\]', str(value)).groups()
                  GPS['GPSLongitude'] = int(match_result[0]), int(match_result[1]), int(match_result[2])
              except:
                  deg, min, sec = [x.replace(' ', '') for x in str(value)[1:-1].split(',')]
                  GPS['GPSLongitude'] = latitude_and_longitude_convert_to_decimal_system(deg, min, sec)
          elif re.match('GPS GPSAltitude', tag):
              GPS['GPSAltitude'] = str(value)
          elif re.match('.*Date.*', tag):
              date = str(value)
  return {'GPS_information': GPS, 'date_information': date}

百度API将GPS转地址

这里需要使用调用百度API，将GPS经纬度信息转换为具体的地址信息。

这里，你需要一个调用百度API的ak值，这个可以注册一个百度开发者获得，当然，你也可以使用博主的这个ak

调用之后，就可以将拍摄时间、拍摄详细地址都解析出来。

def find_address_from_GPS(GPS):
  secret_key = 'zbLsuDDL4CS2U0M4KezOZZbGUY9iWtVf'
  if not GPS['GPS_information']:
      return '该照片无GPS信息'
  #经纬度信息
  lat, lng = GPS['GPS_information']['GPSLatitude'], GPS['GPS_information']['GPSLongitude']
  baidu_map_api = "http://api.map.baidu.com/geocoder/v2/?ak={0}&callback=renderReverse&location={1},{2}s&output=json&pois=0".format(
      secret_key, lat, lng)
  response = requests.get(baidu_map_api)
  #百度API转换成具体的地址
  content = response.text.replace("renderReverse&&renderReverse(", "")[:-1]
  print(content)
  baidu_map_address = json.loads(content)
  #将返回的json信息解析整理出来
  formatted_address = baidu_map_address["result"]["formatted_address"]
  province = baidu_map_address["result"]["addressComponent"]["province"]
  city = baidu_map_address["result"]["addressComponent"]["city"]
  district = baidu_map_address["result"]["addressComponent"]["district"]
  location = baidu_map_address["result"]["sematic_description"]
  return formatted_address,province,city,district,location

if __name__ == '__main__':
  GPS_info = find_GPS_image(pic_path='C:/女友自拍.jpg')
  address = find_address_from_GPS(GPS=GPS_info)
  print("拍摄时间：" + GPS_info.get("date_information"))
  print('照片拍摄地址:' + str(address))

老王得到的结果是这样的

照片拍摄地址:('云南省红河哈尼族彝族自治州弥勒县', '云南省', '红河哈尼族彝族自治州', '弥勒县', '湖泉酒店-A座东南128米')

云南弥勒湖泉酒店，这明显不是老王女友工作的地方，老王搜索了一下，这是一家温泉度假酒店。

顿时就明白了

{"status":0,"result":{"location":{"lng":103.41424699999998,"lat":24.410461020097278},
"formatted_address":"云南省红河哈尼族彝族自治州弥勒县",
"business":"",
"addressComponent":{"country":"中国",
"country_code":0,
"country_code_iso":"CHN",
"country_code_iso2":"CN",
"province":"云南省",
"city":"红河哈尼族彝族自治州",
"city_level":2,"district":"弥勒县",
"town":"","town_code":"","adcode":"532526",
"street_number":"",
"direction":"","distance":""},
"sematic_description":"湖泉酒店-A座东南128米",
"cityCode":107}}

拍摄时间：2021:5:03 20:05:32
照片拍摄地址:('云南省红河哈尼族彝族自治州弥勒县', '云南省', '红河哈尼族彝族自治州', '弥勒县', '湖泉酒店-A座东南128米')

完整代码如下

import exifread
import re
import json
import requests
import os

#转换经纬度格式
def latitude_and_longitude_convert_to_decimal_system(*arg):
  """
  经纬度转为小数, param arg:
  :return: 十进制小数
  """
  return float(arg[0]) + ((float(arg[1]) + (float(arg[2].split('/')[0]) / float(arg[2].split('/')[-1]) / 60)) / 60)

#读取照片的GPS经纬度信息
def find_GPS_image(pic_path):
  GPS = {}
  date = ''
  with open(pic_path, 'rb') as f:
      tags = exifread.process_file(f)
      for tag, value in tags.items():
          #纬度
          if re.match('GPS GPSLatitudeRef', tag):
              GPS['GPSLatitudeRef'] = str(value)
          #经度
          elif re.match('GPS GPSLongitudeRef', tag):
              GPS['GPSLongitudeRef'] = str(value)
          #海拔
          elif re.match('GPS GPSAltitudeRef', tag):
              GPS['GPSAltitudeRef'] = str(value)
          elif re.match('GPS GPSLatitude', tag):
              try:
                  match_result = re.match('\[(\w*),(\w*),(\w.*)/(\w.*)\]', str(value)).groups()
                  GPS['GPSLatitude'] = int(match_result[0]), int(match_result[1]), int(match_result[2])
              except:
                  deg, min, sec = [x.replace(' ', '') for x in str(value)[1:-1].split(',')]
                  GPS['GPSLatitude'] = latitude_and_longitude_convert_to_decimal_system(deg, min, sec)
          elif re.match('GPS GPSLongitude', tag):
              try:
                  match_result = re.match('\[(\w*),(\w*),(\w.*)/(\w.*)\]', str(value)).groups()
                  GPS['GPSLongitude'] = int(match_result[0]), int(match_result[1]), int(match_result[2])
              except:
                  deg, min, sec = [x.replace(' ', '') for x in str(value)[1:-1].split(',')]
                  GPS['GPSLongitude'] = latitude_and_longitude_convert_to_decimal_system(deg, min, sec)
          elif re.match('GPS GPSAltitude', tag):
              GPS['GPSAltitude'] = str(value)
          elif re.match('.*Date.*', tag):
              date = str(value)
  return {'GPS_information': GPS, 'date_information': date}

#通过baidu Map的API将GPS信息转换成地址。
def find_address_from_GPS(GPS):
  """
  使用Geocoding API把经纬度坐标转换为结构化地址。
  :param GPS:
  :return:
  """
  secret_key = 'zbLsuDDL4CS2U0M4KezOZZbGUY9iWtVf'
  if not GPS['GPS_information']:
      return '该照片无GPS信息'
  lat, lng = GPS['GPS_information']['GPSLatitude'], GPS['GPS_information']['GPSLongitude']
  baidu_map_api = "http://api.map.baidu.com/geocoder/v2/?ak={0}&callback=renderReverse&location={1},{2}s&output=json&pois=0".format(
      secret_key, lat, lng)
  response = requests.get(baidu_map_api)
  content = response.text.replace("renderReverse&&renderReverse(", "")[:-1]
  print(content)
  baidu_map_address = json.loads(content)
  formatted_address = baidu_map_address["result"]["formatted_address"]
  province = baidu_map_address["result"]["addressComponent"]["province"]
  city = baidu_map_address["result"]["addressComponent"]["city"]
  district = baidu_map_address["result"]["addressComponent"]["district"]
  location = baidu_map_address["result"]["sematic_description"]
  return formatted_address,province,city,district,location
if __name__ == '__main__':
  GPS_info = find_GPS_image(pic_path='C:/Users/pacer/desktop/img/5.jpg')
  address = find_address_from_GPS(GPS=GPS_info)
  print("拍摄时间：" + GPS_info.get("date_information"))
  print('照片拍摄地址:' + str(address))

作者：LexSaints
来源：https://juejin.cn/post/6967563349609414692

摩斯密码是一种将文本信息作为一系列通断的音调、灯光或咔嗒声传输的方法，无需特殊设备，熟记的小伙伴即可直接翻译。它以电报发明者Samuel F. B. Morse的名字命名。

算法

算法非常简单。英语中的每个字符都被一系列“点”和“破折号”代替，或者有时只是单数的“点”或“破折号”，反之亦然。

加密

1. 在加密的情况下，我们一次一个地从单词中提取每个字符（如果不是空格），并将其与存储在我们选择的任何数据结构中的相应摩斯密码匹配（如果您使用 python 编码，字典可以变成在这种情况下非常有用）

2. 将摩斯密码存储在一个变量中，该变量将包含我们编码的字符串，然后我们在包含结果的字符串中添加一个空格。

3. 在用摩斯密码编码时，我们需要在每个字符之间添加 1 个空格，在每个单词之间添加 2 个连续空格。

4. 如果字符是空格，则向包含结果的变量添加另一个空格。我们重复这个过程，直到我们遍历整个字符串

解密

1. 在解密的情况下，我们首先在要解码的字符串末尾添加一个空格（这将在后面解释）。

2. 现在我们继续从字符串中提取字符，直到我们没有任何空间。

3. 一旦我们得到一个空格，我们就会在提取的字符序列（或我们的莫尔斯电码）中查找相应的英语字符，并将其添加到将存储结果的变量中。

4. 请记住，跟踪空间是此解密过程中最重要的部分。一旦我们得到 2 个连续的空格，我们就会向包含解码字符串的变量添加另一个空格。

5. 字符串末尾的最后一个空格将帮助我们识别莫尔斯电码字符的最后一个序列（因为空格充当提取字符并开始解码它们的检查）。

执行

Python 提供了一种称为字典的数据结构，它以键值对的形式存储信息，这对于实现诸如摩尔斯电码之类的密码非常方便。我们可以将摩斯密码表保存在字典中，其中 （键值对）=>（英文字符-莫尔斯电码） 。明文（英文字符）代替密钥，密文（摩斯密码）形成相应密钥的值。键的值可以从字典中访问，就像我们通过索引访问数组的值一样，反之亦然。

摩斯密码对照表

# 实现摩斯密码翻译器的 Python 程序
 
'''
VARIABLE KEY
'cipher' -> '存储英文字符串的摩斯翻译形式'
'decipher' -> '存储摩斯字符串的英文翻译形式'
'citext' -> '存储单个字符的摩斯密码'
'i' -> '计算摩斯字符之间的空格'
'message' -> '存储要编码或解码的字符串
'''
 
# 表示摩斯密码图的字典
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':'-----', ', ':'--..--', '.':'.-.-.-',
                   '?':'..--..', '/':'-..-.', '-':'-....-',
                   '(':'-.--.', ')':'-.--.-'}
 
# 根据摩斯密码图对字符串进行加密的函数
def encrypt(message):
   cipher = ''
   for letter in message:
       if letter != ' ':
 
           # 查字典并添加对应的摩斯密码
           # 用空格分隔不同字符的摩斯密码
           cipher += MORSE_CODE_DICT[letter] + ' '
       else:
           # 1个空格表示不同的字符
           # 2表示不同的词
           cipher += ' '
 
   return cipher
 
# 将字符串从摩斯解密为英文的函数
def decrypt(message):
 
   # 在末尾添加额外空间以访问最后一个摩斯密码
   message += ' '
 
   decipher = ''
   citext = ''
   for letter in message:
 
       # 检查空间
       if (letter != ' '):
 
           # 计数器来跟踪空间
           i = 0
 
           # 在空格的情况下
           citext += letter
 
       # 在空间的情况下
       else:
           # 如果 i = 1 表示一个新字符
           i += 1
 
           # 如果 i = 2 表示一个新词
           if i == 2 :
 
                # 添加空格来分隔单词
               decipher += ' '
           else:
 
               # 使用它们的值访问密钥（加密的反向）
               decipher += list(MORSE_CODE_DICT.keys())[list(MORSE_CODE_DICT
              .values()).index(citext)]
               citext = ''
 
   return decipher
 
# 硬编码驱动函数来运行程序
def main():
   message = "JUEJIN-HAIYONG"
   result = encrypt(message.upper())
   print (result)

   message = ".--- ..- . .--- .. -. -....- .... .- .. -.-- --- -. --."
   result = decrypt(message)
   print (result)

   message = "I LOVE YOU"
   result = encrypt(message.upper())
   print (result)

   message = ".. .-.. --- ...- . -.-- --- ..-"
   result = decrypt(message)
   print (result)
 
# 执行主函数
if __name__ == '__main__':
   main()

输出：

.--- ..- . .--- .. -. -....- .... .- .. -.-- --- -. --.
JUEJIN-HAIYONG
.. .-.. --- ...- .  -.-- --- ..-
I LOVE YOU

作者：海拥
来源：https://juejin.cn/post/6990223674758397960

Python编程需要遵循的一些规则v2

使用 pylint

pylint 是一个在 Python 源代码中查找 bug 的工具. 对于 C 和 C++ 这样的强类型静态语言来说, 这些 bug 通常由编译器来捕获. 由于 Python 的动态特性, 有些警告可能不对. 不过虚报的情况应该比较少. 确保对你的代码运行 pylint. 在 CI 流程中加入 pylint 检查的步骤. 抑制不准确的警告, 以便其他正确的警告可以暴露出来。

自底向上编程

自底向上编程(bottom up): 从最底层,依赖最少的地方开始设计结构及编写代码, 再编写调用这些代码的逻辑, 自底向上构造程序.

• 采取自底向上的设计方式会让代码更少以及开发过程更加敏捷.

• 自底向上的设计更容易产生符合单一责任原则(SRP) 的代码.

• 组件之间的调用关系清晰, 组件更易复用, 更易编写单元测试案例.

如:需要编写调用外部系统 API 获取数据来完成业务逻辑的代码.

• 应该先编写一个独立的模块将调用外部系统 API 获取数据的接口封装在一些函数中, 然后再编写如何调用这些函数 来完成业务逻辑.

• 不可以先写业务逻辑, 然后在需要调用外部 API 时再去实现相关代码, 这会产生调用 API 的代码直 接耦合在业务逻辑中的代码.

防御式编程

使用 assert 语句确保程序处于的正确状态 不要过度使用 assert, 应该只用于确保核心的部分.

注意 assert 不能代替运行时的异常, 不要忘记 assert 语句可能会被解析器忽略.

assert 语句通常可用于以下场景:

• 确保公共类或者函数被正确地调用 例如一个公共函数可以处理 list 或 dict 类型参数, 在函数开头使用 assert isinstance(param, (list, dict))确保函数接受的参数是 list 或 dict

• assert 用于确保不变量. 防止需求改变时引起代码行为的改变

if target == x:
    run_x_code()
elif target == y:
    run_y_code()
else:
    run_z_code()

假设该代码上线时是正确的, target 只会是 x, y, z 三种情况, 但是稍后如果需求改变了, target 允许 w 的 情况出现. 当 target 为 w 时该代码就会错误地调用 run_z_code, 这通常会引起糟糕的后果.

• 使用 assert 来确保不变量

assert target in (x, y, z)
if target == x:
    run_x_code()
elif target == y:
    run_y_code()
else:
    assert target == z
    run_z_code()

不使用 assert 的场景:

• 不使用 assert 在校验用户输入的数据, 需要校验的情况下应该抛出异常

• 不将 assert 用于允许正常失败的情况, 将 assert 用于检查不允许失败的情况.

• 用户不应该直接看到 AssertionError, 如果用户可以看到, 将这种情况视为一个 BUG

避免使用 magic number

赋予特殊的常量一个名字, 避免重复地直接使用它们的字面值. 合适的时候使用枚举值 Enum.

使用常量在重构时只需要修改一个地方, 如果直接使用字面值在重构时将修改所有使用到的地方.

• 建议

GRAVITATIONAL_CONSTANT = 9.81

def get_potential_energy(mass, height):
    return mass * height * GRAVITATIONAL_CONSTANT

class ConfigStatus:
    ENABLED = 1
    DISABLED = 0

Config.objects.filter(enabled=ConfigStatus.ENABLED)

• 不建议

def get_potential_energy(mass, height):
    return mass * height * 9.81

# Django ORM
Config.objects.filter(enabled=1)

处理字典 key 不存在时的默认值

使用 dict.setdefault 或者 defaultdict

# group words by frequency
words = [(1, 'apple'), (2, 'banana'), (1, 'cat')]
frequency = {}

dict.setdefault

• 建议

for freq, word in words:
    frequency.setdefault(freq, []).append(word)

或者使用 defaultdict

from collections import defaultdict

frequency = defaultdict(list)

for freq, word in words:
    frequency[freq].append(word)

• 不建议

for freq, word in words:
    if freq not in frequency:
        frequency[freq] = []
    frequency[freq].append(word)

注意在 Python 3 中 map filter 返回的是生成器而不是列表, 在隋性计算方面有所区别

禁止使用 import *

原则上禁止避免使用 import *, 应该显式地列出每一个需要导入的模块

使用 import * 会污染当前命名空间的变量, 无法找到变量的定义是来哪个模块, 在被 import 的模块上的改动可 能会在预期外地影响到其它模块, 可能会引起难以排查的问题.

在某些必须需要使用或者是惯用法 from foo import * 的场景下, 应该在模块 foo 的末尾使用 all 控制被导出的变量.

# foo.py
CONST_VALUE = 1
class Apple:
    ...

__all__ = ("CONST_VALUE", "Apple")

# bar.py
# noinspection PyUnresolvedReferences
from foo import *

作者：未来现相
来源：https://mp.weixin.qq.com/s/QinR-bHolVlr0z8IyhCqfg

在讲我们深浅拷贝之前，我们需要先区分一下拷贝和赋值的概念。看下面的例子

a = [1,2,3]

赋值：

b = a

拷贝：

b = a.copy()

上面的两行代码究竟有什么不同呢？带着这个问题，继续

看了上面这张图，相信大家已经对直接赋值和拷贝有了一个比较清楚的认识。

直接赋值：复制一个对象的引用给新变量
拷贝：复制一个对象到新的内存地址空间，并且将新变量引用到复制后的对象

我们的深浅拷贝只是对于可变对象来讨论的。 不熟悉的朋友需要自己去了解可变对象与不可变对象哦。

1 对象的嵌套引用

a = { "list": [1,2,3] }

上面的代码，在内存中是什么样子的呢？请看下图：

原来，在我们的嵌套对象中，子对象也是一个引用。

2 浅拷贝

如上图所示，我们就可以很好的理解什么叫做浅拷贝了。

浅拷贝：只拷贝父对象，不会拷贝对象的内部的子对象。内部的子对象指向的还是同一个引用

上面 的 a 和 c 是一个独立的对象，但他们的子对象还是指向统一对象

2.1 浅拷贝的方法

• .copy()

a = {"list": [1,2,3] }
b = a.copy()

• copy模块

import copy
a = {"list": [1,2,3] }
b = copy.copy(a)

• 列表切片[:]

a = [1,2,3,[1,2,3]]
b = a[1:]

• for循环

a = [1,2,3,[1,2,3]]
b = []
for i in a:
    b.append(i)

2.2 浅拷贝的影响

a = {"list":[1,2,3]}
b = a.copy()
a["list"].append(4)

print(a)
# {'list': [1, 2, 3, 4]}

print(b)
# {'list': [1, 2, 3, 4]}

在上面的例子中，我们明明只改变 a 的子对象，却发现 b 的子对象也跟着改变了。这样在我们的程序中也许会引发很多的BUG。

3 深拷贝

上面我们知道了什么是浅拷贝，那我们的深拷贝就更好理解了。

深拷贝：完全拷贝了父对象及其子对象，两者已经完成没有任何关联，是完全独立的。

import copy
a = {"list":[1,2,3]}
b = copy.deepcopy(a)
a["list"].append(4)

print(a)
# {'list': [1, 2, 3, 4]}

print(b)
# {'list': [1, 2, 3,]}

上面的例子中，我们再次修改 a 的子对象对 b 已经没有任何影响

4 手动实现一个深拷贝

主要采用递归的方法解决问题。判断拷贝的每一项子对象是否为引用对象。如果是就采用递归的方式将子对象进行复制。

def deepcopy(instance):
    if isinstance(instance, dict):
        return {k:deepcopy(v) for k,v in instance.items() }
    
    elif isinstance(instance, list):
        return [deepcopy(x) for x in instance]
    
    else:
        return instance

a = {"list": [1,2,3]}
b = deepcopy(a)

print(a)
# {'list': [1, 2, 3]}

print(b)
# {'list': [1, 2, 3]}

a["list"].append(4)
print(a)
# {'list': [1, 2, 3, 4]}

print(b)
# {'list': [1, 2, 3]}

创作不易，且读且珍惜。如有错漏还请海涵并联系作者修改，内容有参考，如有侵权，请联系作者删除。如果文章对您有帮助，还请动动小手，您的支持是我最大的动力。

字符串驻留机制在许多面向对象编程语言中都支持，比如Java、python、Ruby、PHP等，它是一种数据缓存机制，对不可变数据类型使用同一个内存地址，有效的节省了空间，本文主要介绍Python的内存驻留机制。

驻留

字符串驻留就是每个字符串只有一个副本，多个对象共享该副本，驻留只针对不可变数据类型，比如字符串，布尔值，数字等。在这些固定数据类型处理中，使用驻留可以有效节省时间和空间，当然在驻留池中创建或者插入新的内容会消耗一定的时间。

下面举例介绍python中的驻留机制。
python内存驻留

在Python对象及内存管理机制一文中介绍了python的参数传递以及以及内存管理机制，来看下面一段代码：

l1 = [1, 2, 3, 4]
l2 = [1, 2, 3, 4]
l3 = l2
print(l1 == l2)
print(l1 is l2)
print(l2 == l3)
print(l2 is l3)

知道结果是什么吗？下面是执行结果：

True
False
True
True

l1和l2内容相同，却指向了不同的内存地址，l2和l3之间使用等号赋值，所以指向了同一个对象。因为列表是可变对象，每创建一个列表，都会重新分配内存，列表对象是没有“内存驻留”机制的。下面来看不可变数据类型的驻留机制。

整型驻留

在Jupyter或者控制台交互环境中执行下面代码：

a1 = 300
b1 = 300
c1 = b1
print(a1 is b1)
print(c1 is b1)

a2 = 200
b2 = 200
c2 = b2
print(a2 is b2)
print(c2 is b2)

执行结果：

False
True
True
True

可以发现a1和b1指向了不同的地址，a2和b2指向了相同的地址，这是为什么呢？

因为启动时，Python 将一个 -5~256 之间整数列表预加载（缓存）到内存中，我们在这个范围内创建一个整数对象时，python会自动引用缓存的对象，不会创建新的整数对象。

浮点型不支持：

a = 1.0
b = 1.0
print(a is b)
print(a == b)

# 结果
# False
# True

如果上面的代码在非交互环境，也就是将代码作为python脚本运行的结果是什么呢？（运行环境为python3.7）

True
True
True
True
True
True

全为True，没有明确的限定临界值，都进行了驻留操作。这是因为使用不同的环境时，代码的优化方式不同。

字符串驻留

在Jupyter或者控制台交互环境中：

• 满足标识符命名规范的字符串都会被驻留，长度不限。

• 空字符串会驻留

• 使用乘法得到的字符串且满足标识符命名规范的字符串：长度小于等于20会驻留（peephole优化），Python 3.7改为4096（AST优化器）。

• 长度为1的特殊字符（ASCII 字符中的）会驻留

• 空元组或者只有一个元素且元素范围为-5~256的元组会驻留

满足标识符命名规范的字符：

a = 'Hello World'
b = 'Hello World'
print(a is b)

a = 'Hello_World'
b = 'Hello_World'
print(a is b)

结果：

False
True

乘法获取字符串（运行环境为python3.7）

a = 'aa'*50
b = 'aa'*50
print(a is b)

a = 'aa'*5000
b = 'aa'*5000
print(a is b)

结果：

True
False

在非交互环境中：

• 默认字符串都会驻留

• 使用乘法运算得到的字符串与在控制台相同

• 元组类型（元组内数据为不可变数据类型）会驻留

• 函数、类、变量、参数等的名称以及关键字都会驻留

注意：字符串是在编译时进行驻留，也就是说，如果字符串的值不能在编译时进行计算，将不会驻留。比如下面的例子：

letter = 'd'
a = 'Hello World'
b = 'Hello World'
c = 'Hello Worl' + 'd'
d = 'Hello Worl' + letter
e = " ".join(['Hello','World'])

print(id(a))
print(id(b))
print(id(c))
print(id(d))
print(id(e))

在交互环境执行结果如下：

1696903309168
1696903310128
1696903269296
1696902074160
1696903282800

都指向不同的内存。

python 3.7 非交互环境执行结果：

1426394439728
1426394439728
1426394439728
1426394571504
1426394571440

发现d和e指向不同的内存，因为d和e不是在编译时计算的，而是在运行时计算的。前面的a = 'aa'*50是在编译时计算的。

强行驻留

除了上面介绍的python默认的驻留外，可以使用sys模块中的intern()函数来指定驻留内容

import sys
letter_d = 'd'
a = sys.intern('Hello World')
b = sys.intern('Hello World')
c = sys.intern('Hello Worl' + 'd')
d = sys.intern('Hello Worl' + letter)
e = sys.intern(" ".join(['Hello','World']))

print(id(a))
print(id(b))
print(id(c))
print(id(d))
print(id(e))