在python爬蟲爬取某些網站的驗證碼的時候可能會遇到驗證碼識別的問題，現在的驗證碼大多分為四類：

1、計算驗證碼

2、滑塊驗證碼

3、識圖驗證碼

4、語音驗證碼

這篇博客主要寫的就是識圖驗證碼，識別的是簡單的驗證碼，要想讓識別率更高，識別的更加準確就需要花很多的精力去訓練自己的字體庫。

識別驗證碼通常是這幾個步驟：

1、灰度處理

2、二值化

3、去除邊框(如果有的話)

4、降噪

5、切割字符或者傾斜度矯正

6、訓練字體庫

7、識別

這6個步驟中前三個步驟是基本的，4或者5可根據實際情況選擇是否需要，并不一定切割驗證碼，識別率就會上升很多有時候還會下降

這篇博客不涉及訓練字體庫的內容，請自行搜索。同樣也不講解基礎的語法。

用到的幾個主要的python庫： Pillow(python圖像處理庫)、OpenCV(高級圖像處理庫)、pytesseract(識別庫)

灰度處理&二值化

灰度處理，就是把彩色的驗證碼圖片轉為灰色的圖片。

二值化，是將圖片處理為只有黑白兩色的圖片，利于后面的圖像處理和識別

在OpenCV中有現成的方法可以進行灰度處理和二值化，處理后的效果：

代碼：

1 # 自適應閥值二值化

2 def _get_dynamic_binary_image(filedir, img_name):

3 filename = './out_img/' + img_name.split('.')[0] + '-binary.jpg'

4 img_name = filedir + '/' + img_name

5 print('.....' + img_name)

6 im = cv2.imread(img_name)

7 im = cv2.cvtColor(im,cv2.COLOR_BGR2GRAY) #灰值化

8 # 二值化

9 th1 = cv2.adaptiveThreshold(im, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 21, 1)

10 cv2.imwrite(filename,th1)

11 return th1

去除邊框

如果驗證碼有邊框，那我們就需要去除邊框，去除邊框就是遍歷像素點，找到四個邊框上的所有點，把他們都改為白色，我這里邊框是兩個像素寬

注意：在用OpenCV時，圖片的矩陣點是反的，就是長和寬是顛倒的

代碼：

# 去除邊框

def clear_border(img,img_name):

filename = './out_img/' + img_name.split('.')[0] + '-clearBorder.jpg'

h, w = img.shape[:2]

for y in range(0, w):

for x in range(0, h):

if y < 2 or y > w - 2:

img[x, y] = 255

if x < 2 or x > h -2:

img[x, y] = 255

cv2.imwrite(filename,img)

return img

效果：

降噪

降噪是驗證碼處理中比較重要的一個步驟，我這里使用了點降噪和線降噪

線降噪的思路就是檢測這個點相鄰的四個點(圖中標出的綠色點)，判斷這四個點中是白點的個數，如果有兩個以上的白色像素點，那么就認為這個點是白色的，從而去除整個干擾線，但是這種方法是有限度的，如果干擾線特別粗就沒有辦法去除，只能去除細的干擾線

代碼：

1 # 干擾線降噪

2 def interference_line(img, img_name):

3 filename = './out_img/' + img_name.split('.')[0] + '-interferenceline.jpg'

4 h, w = img.shape[:2]

5 # ！！！opencv矩陣點是反的

6 # img[1,2] 1:圖片的高度，2：圖片的寬度

7 for y in range(1, w - 1):

8 for x in range(1, h - 1):

9 count = 0

10 if img[x, y - 1] > 245:

11 count = count + 1

12 if img[x, y + 1] > 245:

13 count = count + 1

14 if img[x - 1, y] > 245:

15 count = count + 1

16 if img[x + 1, y] > 245:

17 count = count + 1

18 if count > 2:

19 img[x, y] = 255

20 cv2.imwrite(filename,img)

21 return img

點降噪的思路和線降噪的差不多，只是會針對不同的位置檢測的點不一樣,注釋寫的很清楚了

代碼：

# 點降噪

def interference_point(img,img_name, x = 0, y = 0):

"""

9鄰域框,以當前點為中心的田字框,黑點個數

:param x:

:param y:

:return:

"""

filename = './out_img/' + img_name.split('.')[0] + '-interferencePoint.jpg'

# todo 判斷圖片的長寬度下限

cur_pixel = img[x,y]# 當前像素點的值

height,width = img.shape[:2]

for y in range(0, width - 1):

for x in range(0, height - 1):

if y == 0: # 第一行

if x == 0: # 左上頂點,4鄰域

# 中心點旁邊3個點

sum = int(cur_pixel) \

+ int(img[x, y + 1]) \

+ int(img[x + 1, y]) \

+ int(img[x + 1, y + 1])

if sum <= 2 * 245:

img[x, y] = 0

elif x == height - 1: # 右上頂點

sum = int(cur_pixel) \

+ int(img[x, y + 1]) \

+ int(img[x - 1, y]) \

+ int(img[x - 1, y + 1])

if sum <= 2 * 245:

img[x, y] = 0

else: # 最上非頂點,6鄰域

sum = int(img[x - 1, y]) \

+ int(img[x - 1, y + 1]) \

+ int(cur_pixel) \

+ int(img[x, y + 1]) \

+ int(img[x + 1, y]) \

+ int(img[x + 1, y + 1])

if sum <= 3 * 245:

img[x, y] = 0

elif y == width - 1: # 最下面一行

if x == 0: # 左下頂點

# 中心點旁邊3個點

sum = int(cur_pixel) \

+ int(img[x + 1, y]) \

+ int(img[x + 1, y - 1]) \

+ int(img[x, y - 1])

if sum <= 2 * 245:

img[x, y] = 0

elif x == height - 1: # 右下頂點

sum = int(cur_pixel) \

+ int(img[x, y - 1]) \

+ int(img[x - 1, y]) \

+ int(img[x - 1, y - 1])

if sum <= 2 * 245:

img[x, y] = 0

else: # 最下非頂點,6鄰域

sum = int(cur_pixel) \

+ int(img[x - 1, y]) \

+ int(img[x + 1, y]) \

+ int(img[x, y - 1]) \

+ int(img[x - 1, y - 1]) \

+ int(img[x + 1, y - 1])

if sum <= 3 * 245:

img[x, y] = 0

else: # y不在邊界

if x == 0: # 左邊非頂點

sum = int(img[x, y - 1]) \

+ int(cur_pixel) \

+ int(img[x, y + 1]) \

+ int(img[x + 1, y - 1]) \

+ int(img[x + 1, y]) \

+ int(img[x + 1, y + 1])

if sum <= 3 * 245:

img[x, y] = 0

elif x == height - 1: # 右邊非頂點

sum = int(img[x, y - 1]) \

+ int(cur_pixel) \

+ int(img[x, y + 1]) \

+ int(img[x - 1, y - 1]) \

+ int(img[x - 1, y]) \

+ int(img[x - 1, y + 1])

if sum <= 3 * 245:

img[x, y] = 0

else: # 具備9領域條件的

sum = int(img[x - 1, y - 1]) \

+ int(img[x - 1, y]) \

+ int(img[x - 1, y + 1]) \

+ int(img[x, y - 1]) \

+ int(cur_pixel) \

+ int(img[x, y + 1]) \

+ int(img[x + 1, y - 1]) \

+ int(img[x + 1, y]) \

+ int(img[x + 1, y + 1])

if sum <= 4 * 245:

img[x, y] = 0

cv2.imwrite(filename,img)

return img

效果：

其實到了這一步，這些字符就可以識別了，沒必要進行字符切割了，現在這三種類型的驗證碼識別率已經達到50%以上了

字符切割

字符切割通常用于驗證碼中有粘連的字符，粘連的字符不好識別，所以我們需要將粘連的字符切割為單個的字符，在進行識別

字符切割的思路就是找到一個黑色的點，然后在遍歷與他相鄰的黑色的點，直到遍歷完所有的連接起來的黑色的點，找出這些點中的最高的點、最低的點、最右邊的點、最左邊的點，記錄下這四個點，認為這是一個字符，然后在向后遍歷點，直至找到黑色的點，繼續以上的步驟。最后通過每個字符的四個點進行切割

圖中紅色的點就是代碼執行完后，標識出的每個字符的四個點，然后就會根據這四個點進行切割(圖中畫的有些誤差，懂就好)

但是也可以看到，m2是粘連的，代碼認為他是一個字符，所以我們需要對每個字符的寬度進行檢測，如果他的寬度過寬，我們就認為他是兩個粘連在一起的字符，并將它在從中間切割

確定每個字符的四個點代碼：

def cfs(im,x_fd,y_fd):

'''用隊列和集合記錄遍歷過的像素坐標代替單純遞歸以解決cfs訪問過深問題

'''

# print('**********')

xaxis=[]

yaxis=[]

visited =set()

q = Queue()

q.put((x_fd, y_fd))

visited.add((x_fd, y_fd))

offsets=[(1, 0), (0, 1), (-1, 0), (0, -1)]#四鄰域

while not q.empty():

x,y=q.get()

for xoffset,yoffset in offsets:

x_neighbor,y_neighbor = x+xoffset,y+yoffset

if (x_neighbor,y_neighbor) in (visited):

continue # 已經訪問過了

visited.add((x_neighbor, y_neighbor))

try:

if im[x_neighbor, y_neighbor] == 0:

xaxis.append(x_neighbor)

yaxis.append(y_neighbor)

q.put((x_neighbor,y_neighbor))

except IndexError:

pass

# print(xaxis)

if (len(xaxis) == 0 | len(yaxis) == 0):

xmax = x_fd + 1

xmin = x_fd

ymax = y_fd + 1

ymin = y_fd

else:

xmax = max(xaxis)

xmin = min(xaxis)

ymax = max(yaxis)

ymin = min(yaxis)

#ymin,ymax=sort(yaxis)

return ymax,ymin,xmax,xmin

def detectFgPix(im,xmax):

'''搜索區塊起點

'''

h,w = im.shape[:2]

for y_fd in range(xmax+1,w):

for x_fd in range(h):

if im[x_fd,y_fd] == 0:

return x_fd,y_fd

def CFS(im):

'''切割字符位置

'''

zoneL=[]#各區塊長度L列表

zoneWB=[]#各區塊的X軸[起始，終點]列表

zoneHB=[]#各區塊的Y軸[起始，終點]列表

xmax=0#上一區塊結束黑點橫坐標,這里是初始化

for i in range(10):

try:

x_fd,y_fd = detectFgPix(im,xmax)

# print(y_fd,x_fd)

xmax,xmin,ymax,ymin=cfs(im,x_fd,y_fd)

L = xmax - xmin

H = ymax - ymin

zoneL.append(L)

zoneWB.append([xmin,xmax])

zoneHB.append([ymin,ymax])

except TypeError:

return zoneL,zoneWB,zoneHB

return zoneL,zoneWB,zoneHB

分割粘連字符代碼：

# 切割的位置

im_position = CFS(im)

maxL = max(im_position[0])

minL = min(im_position[0])

# 如果有粘連字符，如果一個字符的長度過長就認為是粘連字符，并從中間進行切割

if(maxL > minL + minL * 0.7):

maxL_index = im_position[0].index(maxL)

minL_index = im_position[0].index(minL)

# 設置字符的寬度

im_position[0][maxL_index] = maxL // 2

im_position[0].insert(maxL_index + 1, maxL // 2)

# 設置字符X軸[起始，終點]位置

im_position[1][maxL_index][1] = im_position[1][maxL_index][0] + maxL // 2

im_position[1].insert(maxL_index + 1, [im_position[1][maxL_index][1] + 1, im_position[1][maxL_index][1] + 1 + maxL // 2])

# 設置字符的Y軸[起始，終點]位置

im_position[2].insert(maxL_index + 1, im_position[2][maxL_index])

# 切割字符，要想切得好就得配置參數，通常 1 or 2 就可以

cutting_img(im,im_position,img_name,1,1)

切割粘連字符代碼：

def cutting_img(im,im_position,img,xoffset = 1,yoffset = 1):

filename = './out_img/' + img.split('.')[0]

# 識別出的字符個數

im_number = len(im_position[1])

# 切割字符

for i in range(im_number):

im_start_X = im_position[1][i][0] - xoffset

im_end_X = im_position[1][i][1] + xoffset

im_start_Y = im_position[2][i][0] - yoffset

im_end_Y = im_position[2][i][1] + yoffset

cropped = im[im_start_Y:im_end_Y, im_start_X:im_end_X]

cv2.imwrite(filename + '-cutting-' + str(i) + '.jpg',cropped)

效果：

識別

識別用的是typesseract庫，主要識別一行字符和單個字符時的參數設置，識別中英文的參數設置，代碼很簡單就一行，我這里大多是filter文件的操作

代碼：

# 識別驗證碼

cutting_img_num = 0

for file in os.listdir('./out_img'):

str_img = ''

if fnmatch(file, '%s-cutting-*.jpg' % img_name.split('.')[0]):

cutting_img_num += 1

for i in range(cutting_img_num):

try:

file = './out_img/%s-cutting-%s.jpg' % (img_name.split('.')[0], i)

# 識別字符

str_img = str_img + image_to_string(Image.open(file),lang = 'eng', config='-psm 10') #單個字符是10，一行文本是7

except Exception as err:

pass

print('切圖：%s' % cutting_img_num)

print('識別為：%s' % str_img)

最后這種粘連字符的識別率是在30%左右，而且這種只是處理兩個字符粘連，如果有兩個以上的字符粘連還不能識別，但是根據字符寬度判別的話也不難，有興趣的可以試一下

無需切割字符識別的效果：

需要切割字符的識別效果：

這種只是能夠識別簡單驗證碼，復雜的驗證碼還要靠大家了

參考資料：

1、http://www.jianshu.com/p/41127bf90ca9

本來參考了挺多的資料，但是時間長了就找不到了，如果有人發現了，可以告訴我，我再添加

使用方法：

1、將要識別的驗證碼圖片放入與腳本同級的img文件夾中，創建out_img文件夾

2、python3 filename

3、二值化、降噪等各個階段的圖片將存儲在out_img文件夾中，最終識別結果會打印到屏幕上

最后附上源碼(帶切割，不想要切割的就自己修改吧)：

1 from PIL import Image

2 from pytesseract import *

3 from fnmatch import fnmatch

4 from queue import Queue

5 import matplotlib.pyplot as plt

6 import cv2

7 import time

8 import os

9

10

11

12

13

14 def clear_border(img,img_name):

15 '''去除邊框

16 '''

17

18 filename = './out_img/' + img_name.split('.')[0] + '-clearBorder.jpg'

19 h, w = img.shape[:2]

20 for y in range(0, w):

21 for x in range(0, h):

22 # if y ==0 or y == w -1 or y == w - 2:

23 if y < 4 or y > w -4:

24 img[x, y] = 255

25 # if x == 0 or x == h - 1 or x == h - 2:

26 if x < 4 or x > h - 4:

27 img[x, y] = 255

28

29 cv2.imwrite(filename,img)

30 return img

31

32

33 def interference_line(img, img_name):

34 '''

35 干擾線降噪

36 '''

37

38 filename = './out_img/' + img_name.split('.')[0] + '-interferenceline.jpg'

39 h, w = img.shape[:2]

40 # ！！！opencv矩陣點是反的

41 # img[1,2] 1:圖片的高度，2：圖片的寬度

42 for y in range(1, w - 1):

43 for x in range(1, h - 1):

44 count = 0

45 if img[x, y - 1] > 245:

46 count = count + 1

47 if img[x, y + 1] > 245:

48 count = count + 1

49 if img[x - 1, y] > 245:

50 count = count + 1

51 if img[x + 1, y] > 245:

52 count = count + 1

53 if count > 2:

54 img[x, y] = 255

55 cv2.imwrite(filename,img)

56 return img

57

58 def interference_point(img,img_name, x = 0, y = 0):

59 """點降噪

60 9鄰域框,以當前點為中心的田字框,黑點個數

61 :param x:

62 :param y:

63 :return:

64 """

65 filename = './out_img/' + img_name.split('.')[0] + '-interferencePoint.jpg'

66 # todo 判斷圖片的長寬度下限

67 cur_pixel = img[x,y]# 當前像素點的值

68 height,width = img.shape[:2]

69

70 for y in range(0, width - 1):

71 for x in range(0, height - 1):

72 if y == 0: # 第一行

73 if x == 0: # 左上頂點,4鄰域

74 # 中心點旁邊3個點

75 sum = int(cur_pixel) \

76 + int(img[x, y + 1]) \

77 + int(img[x + 1, y]) \

78 + int(img[x + 1, y + 1])

79 if sum <= 2 * 245:

80 img[x, y] = 0

81 elif x == height - 1: # 右上頂點

82 sum = int(cur_pixel) \

83 + int(img[x, y + 1]) \

84 + int(img[x - 1, y]) \

85 + int(img[x - 1, y + 1])

86 if sum <= 2 * 245:

87 img[x, y] = 0

88 else: # 最上非頂點,6鄰域

89 sum = int(img[x - 1, y]) \

90 + int(img[x - 1, y + 1]) \

91 + int(cur_pixel) \

92 + int(img[x, y + 1]) \

93 + int(img[x + 1, y]) \

94 + int(img[x + 1, y + 1])

95 if sum <= 3 * 245:

96 img[x, y] = 0

97 elif y == width - 1: # 最下面一行

98 if x == 0: # 左下頂點

99 # 中心點旁邊3個點

100 sum = int(cur_pixel) \

101 + int(img[x + 1, y]) \

102 + int(img[x + 1, y - 1]) \

103 + int(img[x, y - 1])

104 if sum <= 2 * 245:

105 img[x, y] = 0

106 elif x == height - 1: # 右下頂點

107 sum = int(cur_pixel) \

108 + int(img[x, y - 1]) \

109 + int(img[x - 1, y]) \

110 + int(img[x - 1, y - 1])

111

112 if sum <= 2 * 245:

113 img[x, y] = 0

114 else: # 最下非頂點,6鄰域

115 sum = int(cur_pixel) \

116 + int(img[x - 1, y]) \

117 + int(img[x + 1, y]) \

118 + int(img[x, y - 1]) \

119 + int(img[x - 1, y - 1]) \

120 + int(img[x + 1, y - 1])

121 if sum <= 3 * 245:

122 img[x, y] = 0

123 else: # y不在邊界

124 if x == 0: # 左邊非頂點

125 sum = int(img[x, y - 1]) \

126 + int(cur_pixel) \

127 + int(img[x, y + 1]) \

128 + int(img[x + 1, y - 1]) \

129 + int(img[x + 1, y]) \

130 + int(img[x + 1, y + 1])

131

132 if sum <= 3 * 245:

133 img[x, y] = 0

134 elif x == height - 1: # 右邊非頂點

135 sum = int(img[x, y - 1]) \

136 + int(cur_pixel) \

137 + int(img[x, y + 1]) \

138 + int(img[x - 1, y - 1]) \

139 + int(img[x - 1, y]) \

140 + int(img[x - 1, y + 1])

141

142 if sum <= 3 * 245:

143 img[x, y] = 0

144 else: # 具備9領域條件的

145 sum = int(img[x - 1, y - 1]) \

146 + int(img[x - 1, y]) \

147 + int(img[x - 1, y + 1]) \

148 + int(img[x, y - 1]) \

149 + int(cur_pixel) \

150 + int(img[x, y + 1]) \

151 + int(img[x + 1, y - 1]) \

152 + int(img[x + 1, y]) \

153 + int(img[x + 1, y + 1])

154 if sum <= 4 * 245:

155 img[x, y] = 0

156 cv2.imwrite(filename,img)

157 return img

158

159 def _get_dynamic_binary_image(filedir, img_name):

160 '''

161 自適應閥值二值化

162 '''

163

164 filename = './out_img/' + img_name.split('.')[0] + '-binary.jpg'

165 img_name = filedir + '/' + img_name

166 print('.....' + img_name)

167 im = cv2.imread(img_name)

168 im = cv2.cvtColor(im,cv2.COLOR_BGR2GRAY)

169

170 th1 = cv2.adaptiveThreshold(im, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 21, 1)

171 cv2.imwrite(filename,th1)

172 return th1

173

174 def _get_static_binary_image(img, threshold = 140):

175 '''

176 手動二值化

177 '''

178

179 img = Image.open(img)

180 img = img.convert('L')

181 pixdata = img.load()

182 w, h = img.size

183 for y in range(h):

184 for x in range(w):

185 if pixdata[x, y] < threshold:

186 pixdata[x, y] = 0

187 else:

188 pixdata[x, y] = 255

189

190 return img

191

192

193 def cfs(im,x_fd,y_fd):

194 '''用隊列和集合記錄遍歷過的像素坐標代替單純遞歸以解決cfs訪問過深問題

195 '''

196

197 # print('**********')

198

199 xaxis=[]

200 yaxis=[]

201 visited =set()

202 q = Queue()

203 q.put((x_fd, y_fd))

204 visited.add((x_fd, y_fd))

205 offsets=[(1, 0), (0, 1), (-1, 0), (0, -1)]#四鄰域

206

207 while not q.empty():

208 x,y=q.get()

209

210 for xoffset,yoffset in offsets:

211 x_neighbor,y_neighbor = x+xoffset,y+yoffset

212

213 if (x_neighbor,y_neighbor) in (visited):

214 continue # 已經訪問過了

215

216 visited.add((x_neighbor, y_neighbor))

217

218 try:

219 if im[x_neighbor, y_neighbor] == 0:

220 xaxis.append(x_neighbor)

221 yaxis.append(y_neighbor)

222 q.put((x_neighbor,y_neighbor))

223

224 except IndexError:

225 pass

226 # print(xaxis)

227 if (len(xaxis) == 0 | len(yaxis) == 0):

228 xmax = x_fd + 1

229 xmin = x_fd

230 ymax = y_fd + 1

231 ymin = y_fd

232

233 else:

234 xmax = max(xaxis)

235 xmin = min(xaxis)

236 ymax = max(yaxis)

237 ymin = min(yaxis)

238 #ymin,ymax=sort(yaxis)

239

240 return ymax,ymin,xmax,xmin

241

242 def detectFgPix(im,xmax):

243 '''搜索區塊起點

244 '''

245

246 h,w = im.shape[:2]

247 for y_fd in range(xmax+1,w):

248 for x_fd in range(h):

249 if im[x_fd,y_fd] == 0:

250 return x_fd,y_fd

251

252 def CFS(im):

253 '''切割字符位置

254 '''

255

256 zoneL=[]#各區塊長度L列表

257 zoneWB=[]#各區塊的X軸[起始，終點]列表

258 zoneHB=[]#各區塊的Y軸[起始，終點]列表

259

260 xmax=0#上一區塊結束黑點橫坐標,這里是初始化

261 for i in range(10):

262

263 try:

264 x_fd,y_fd = detectFgPix(im,xmax)

265 # print(y_fd,x_fd)

266 xmax,xmin,ymax,ymin=cfs(im,x_fd,y_fd)

267 L = xmax - xmin

268 H = ymax - ymin

269 zoneL.append(L)

270 zoneWB.append([xmin,xmax])

271 zoneHB.append([ymin,ymax])

272

273 except TypeError:

274 return zoneL,zoneWB,zoneHB

275

276 return zoneL,zoneWB,zoneHB

277

278

279 def cutting_img(im,im_position,img,xoffset = 1,yoffset = 1):

280 filename = './out_img/' + img.split('.')[0]

281 # 識別出的字符個數

282 im_number = len(im_position[1])

283 # 切割字符

284 for i in range(im_number):

285 im_start_X = im_position[1][i][0] - xoffset

286 im_end_X = im_position[1][i][1] + xoffset

287 im_start_Y = im_position[2][i][0] - yoffset

288 im_end_Y = im_position[2][i][1] + yoffset

289 cropped = im[im_start_Y:im_end_Y, im_start_X:im_end_X]

290 cv2.imwrite(filename + '-cutting-' + str(i) + '.jpg',cropped)

291

292

293

294 def main():

295 filedir = './easy_img'

296

297 for file in os.listdir(filedir):

298 if fnmatch(file, '*.jpeg'):

299 img_name = file

300

301 # 自適應閾值二值化

302 im = _get_dynamic_binary_image(filedir, img_name)

303

304 # 去除邊框

305 im = clear_border(im,img_name)

306

307 # 對圖片進行干擾線降噪

308 im = interference_line(im,img_name)

309

310 # 對圖片進行點降噪

311 im = interference_point(im,img_name)

312

313 # 切割的位置

314 im_position = CFS(im)

315

316 maxL = max(im_position[0])

317 minL = min(im_position[0])

318

319 # 如果有粘連字符，如果一個字符的長度過長就認為是粘連字符，并從中間進行切割

320 if(maxL > minL + minL * 0.7):

321 maxL_index = im_position[0].index(maxL)

322 minL_index = im_position[0].index(minL)

323 # 設置字符的寬度

324 im_position[0][maxL_index] = maxL // 2

325 im_position[0].insert(maxL_index + 1, maxL // 2)

326 # 設置字符X軸[起始，終點]位置

327 im_position[1][maxL_index][1] = im_position[1][maxL_index][0] + maxL // 2

328 im_position[1].insert(maxL_index + 1, [im_position[1][maxL_index][1] + 1, im_position[1][maxL_index][1] + 1 + maxL // 2])

329 # 設置字符的Y軸[起始，終點]位置

330 im_position[2].insert(maxL_index + 1, im_position[2][maxL_index])

331

332 # 切割字符，要想切得好就得配置參數，通常 1 or 2 就可以

333 cutting_img(im,im_position,img_name,1,1)

334

335 # 識別驗證碼

336 cutting_img_num = 0

337 for file in os.listdir('./out_img'):

338 str_img = ''

339 if fnmatch(file, '%s-cutting-*.jpg' % img_name.split('.')[0]):

340 cutting_img_num += 1

341 for i in range(cutting_img_num):

342 try:

343 file = './out_img/%s-cutting-%s.jpg' % (img_name.split('.')[0], i)

344 # 識別驗證碼

345 str_img = str_img + image_to_string(Image.open(file),lang = 'eng', config='-psm 10') #單個字符是10，一行文本是7

346 except Exception as err:

347 pass

348 print('切圖：%s' % cutting_img_num)

349 print('識別為：%s' % str_img)

350

351 if __name__ == '__main__':

352 main()

View Code

不要在該奮斗的年紀選擇了安逸

本文轉自:http://www.cnblogs.com/qqandfqr/p/7866650.html

總結

以上是生活随笔為你收集整理的python语音验证码识别_python验证码自动识别的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。