发布于

文件批量处理

  1. 批量重命名文件
    在这里最核心的就是os.listdir(），这个函数可以返回文件夹里所有文件的文件名. 有了这个我们才能进行其他操作，包括遍历。
import sys
import os                                 #OS库是文件处理中经常用到的库
import comtypes.client
#单个word转PDF
wdFormatPDF = 17
addr = 'C:\\Users\\wang\\Desktop\\G13-a\\'   #文件夹的绝对路径

names = os.listdir(addr)                        # 读取文件夹下的所有文件名

#进行遍历
for name in names:                         
    old_name = addr + name                 #注意rename函数里要放完整的路径，不能只放新旧名字
    new_name = addr + name[:13]            #这是当时甲方要求去除后缀，故只取旧题目的前13位
    os.rename (old_name, new_name)

2. 文件分类
在tender的最后提交时，甲方要求按工作编号进行提交，这里需要按照register里的编号进行分类。

首先读取文档，观察数据形式

import pandas as pd
df = pd.read_excel('C:\\Users\\wang\\Desktop\\DCC_file.xlsx')
通过读取register发现我们需要根据“DCC”列进行分类，而对应的文件名在“NATIVE”列

接下来，需要完成的就是：（1） 获取每一类DCC编码下的文件名；（2）复制对应文件名至相应文件夹。

其中文档的复制移动主要依靠shutil模块.

import os
import shutil 

file_dir = r'C:\Users\wang\Desktop\All file'     #这里是存放所有文件的位置，它们需要进行分类

os.chdir(file_dir)    

numb = '10-01902-0002-050'   #这是其中一个DCC 编码
os.mkdir(numb)          #在当前路径下创建对应的文件夹 

filenames = df.loc[(df['DCC']== numb)]['NATIVE']    #利用loc函数筛选出 '10-01902-0002-050' 对应的所有文件名

# 这里操作是因为DC部门在命名文件时，Pdf， Word 和drawing的文件名后三位分别是“P00”,“W00”和“V00”,
# 所以通过这个，为对应的文件名加上对应的后缀，来构成完整的文件名

for name in filenames:      
 
    if name[-3] == 'X':
        fname = name + '.xls'
    if name[-3] == 'V':
        fname = name + '.dgn'
    if name[-3] == 'W':
        fname = name + '.doc'
    
    if os.path.exists(fname) ==1:        #判断文件是否存在
        shutil.copy(fname,numb)         #复制文件至文件夹
    else:
        print(fname)                     #输出不存在的文件名，用来检查

3. 批量Word转PDF

这个很常见的需求，需要将word转为PDF，但传统的Adobe转PDF需要一个一个点，比较慢，而网上大部分批量转PDF的软件基本收费，所以也是临时想起用python写个小程序。

这里呢，如前面提到的DC要求，转换得到的PDF，名字后三位需要时“P00″, 例如C860040001W00.doc 转换后的PDF应该是 C860040001W00.pdf.

所以这里目标有两个：

（1） 遍历，也就是达到批量处理的目的

（2） 重命名后三位为”P00″

这里用到的库是 comtypes.client，用它访问COM组件达到转PDF的目的。

import sys
import os
import comtypes.client

wdFormatPDF = 17

addr = 'C:\\Users\\wang\\Desktop\\doc\\10-01902-0002-711\\' # 目标路径，存放word的位置

doc_names = os.listdir(addr)  #读取文件夹里所有文件的名字
pdf_names = []              #将用来存放转换后PDF的名字

#开始遍历
for name in doc_names:     
    pdf_name = name[:10] +'P00.pdf'    #实现文件名转换：C860040001W00.doc 到 C860040001W00.pdf.
    pdf_names.append(pdf_name)  #存放新的PDF文档文件名
    in_file = os.path.abspath(addr + name)  #构造完整路径的文件名
    out_file = os.path.abspath(addr + pdf_name)
    word = comtypes.client.CreateObject('Word.Application')
    doc = word.Documents.Open(in_file)
    doc.SaveAs(out_file, FileFormat=wdFormatPDF)   #转换为PDF
    doc.Close()
    word.Quit()

有了这些小程序，基本可以处理工作中的文档操作了！感谢Python让我现在有时间喝咖啡写文章，而不用继续click，click，click.

发布于

Django根据已有的数据库来生成模型

日常开发中，我们有时会碰到数据库已经存在，而需要我们去生成模型的情况。这种情况下，我们需要：

Django中配置好数据库，确保连接得上这个已经存在的数据库
在cmd中运行命令，模型会生成在同一个文件中

 python manage.py inspectdb > models.py


修改模型
3.1 修改模型名，根据需求修改模型的名称
3.2 将不同的表放进其所属的app中
3.3 处理好表之间的外键关系（主要针对跨app的表，如果外键在同一个模型文件中，则可以跳过该步骤），在外键前加上app_name
3.4 让Django能够管理该模型并进行迁移：将Meta下的managed = False删除
3.5 当有多对多关系的表时，删除模型中的中间表，使用ManyToManyField来实现多对多，注意要设置中间表的名称让其与数据库中的中间表名一致
3.6 切记不要修改模型中的表名称，与数据库不一致的话会导致找不到表的错误
运行 python manage.py makemigrations
运行 python manage.py migrate –fake-initial
其中，在修改模型的时候，重点是需要分析好表与表之间的关系，只要能够弄清楚表与表之间的关系，那么修改模型会轻松很多

发布于

Django学习笔记：KeyError

处理Python关于Dict的错误KeyError的办法挺多，不过就记下了2个：

方法一：使用setdefault()设置默认值，如

data.setdefault('error', 0)

方法二：导入collections，使用defaultdict方法

data = collections.defaultdict(list, data)
发布于

Django详解之models操作

原文链接：https://www.cnblogs.com/allan-king/p/5807659.html

Django 模型是与数据库相关的，与数据库相关的代码一般写在 models.py 中，Django 支持 sqlite3, MySQL, PostgreSQL等数据库，只需要在settings.py中配置即可，不用更改models.py中的代码，丰富的API极大的方便了使用。 1、数据库的连接方式以及设置： 在Django中默认使用的数据库类型是sqlite3，如果想要使用其他数据库就需要在settings中设置数据库的连接方式：

# Database
# https://docs.djangoproject.com/en/1.10/ref/settings/#databases
 
# sqlite3数据库连接方式
# DATABASES = {
#     'default': {
#         'ENGINE': 'django.db.backends.sqlite3',
#         'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
#     }
# }
 
# MySQL数据库连接方式
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME':'dbname',
'USER': 'root',
'PASSWORD': 'xxx',
'HOST': '',
'PORT': '',
}
}

2、开始创建表
数据需要在models.py文件中创建

 class UserInfo(models.Model):
# CharField类型不能为空,最少要指定一个长度
user = models.CharField(max_length=32)
email = models.EmailField(max_length=32)
pwd = models.CharField(max_length=32)
user_type = models.ForeignKey('UserType')
 
class UserType(models.Model):
nid = models.AutoField(primary_key=True)
caption = models.CharField(max_length=16)

注:在创建外键的时候直接写上UserType和’UserType’的区别就是python程序从上到下解释的顺序问题,如果把UserType这个类写到下面就会没事了
运行Djando项目程序，执行命令创建数据：

python3 manage.py makemigrations
python3 manage.py migrate

创建表的的参数：

1、models.AutoField　　自增列 = int(11)
 　　如果没有的话，默认会生成一个名称为 id 的列，如果要显示的自定义一个自增列，必须将给列设置为主键 primary_key=True。
 2、models.CharField　　字符串字段
 　　必须 max_length 参数
 3、models.BooleanField　　布尔类型=tinyint(1)
 　　不能为空，Blank=True
 4、models.ComaSeparatedIntegerField　　用逗号分割的数字=varchar
 　　继承CharField，所以必须 max_lenght 参数
 5、models.DateField　　日期类型 date
 　　对于参数，auto_now = True 则每次更新都会更新这个时间；auto_now_add 则只是第一次创建添加，之后的更新不再改变。
 6、models.DateTimeField　　日期类型 datetime
 　　同DateField的参数
 7、models.Decimal　　十进制小数类型 = decimal
 　　必须指定整数位max_digits和小数位decimal_places
 8、models.EmailField　　字符串类型（正则表达式邮箱） =varchar
 　　对字符串进行正则表达式
 9、models.FloatField　　浮点类型 = double
 10、models.IntegerField　　整形
 11、models.BigIntegerField　　长整形
 　　integer_field_ranges = {
 　　　　'SmallIntegerField': (-32768, 32767),
 　　　　'IntegerField': (-2147483648, 2147483647),
 　　　　'BigIntegerField': (-9223372036854775808, 9223372036854775807),
 　　　　'PositiveSmallIntegerField': (0, 32767),
 　　　　'PositiveIntegerField': (0, 2147483647),
 　　}
 12、models.IPAddressField　　字符串类型（ip4正则表达式）
 13、models.GenericIPAddressField　　字符串类型（ip4和ip6是可选的）
 　　参数protocol可以是：both、ipv4、ipv6
 　　验证时，会根据设置报错
 14、models.NullBooleanField　　允许为空的布尔类型
 15、models.PositiveIntegerFiel　　正Integer
 16、models.PositiveSmallIntegerField　　正smallInteger
 17、models.SlugField　　减号、下划线、字母、数字
 18、models.SmallIntegerField　　数字
 　　数据库中的字段有：tinyint、smallint、int、bigint
 19、models.TextField　　字符串=longtext
 20、models.TimeField　　时间 HH:MM[:ss[.uuuuuu]]
 21、models.URLField　　字符串，地址正则表达式
 22、models.BinaryField　　二进制
 23、models.ImageField   图片
 24、models.FilePathField 文件
 更多字段
1、null=True
　　数据库中字段是否可以为空
2、blank=True
　　django的 Admin 中添加数据时是否可允许空值
3、primary_key = False
　　主键，对AutoField设置主键后，就会代替原来的自增 id 列
4、auto_now 和 auto_now_add
　　auto_now   自动创建---无论添加或修改，都是当前操作的时间
　　auto_now_add  自动创建---永远是创建时的时间
5、choices
GENDER_CHOICE = (
        (u'M', u'Male'),
        (u'F', u'Female'),
    )
gender = models.CharField(max_length=2,choices = GENDER_CHOICE)
6、max_length
7、default　　默认值
8、verbose_name　　Admin中字段的显示名称
9、name|db_column　　数据库中的字段名称
10、unique=True　　不允许重复
11、db_index = True　　数据库索引
12、editable=True　　在Admin里是否可编辑
13、error_messages=None　　错误提示
14、auto_created=False　　自动创建
15、help_text　　在Admin中提示帮助信息
16、validators=[]
17、upload-to

更多参数

执行成功状态：

1 bogon:django_modes01 zk$ python3 manage.py makemigrations
 2 Migrations for 'app01':
 3   app01/migrations/0001_initial.py:
 4     - Create model UserInfo
 5     - Create model UserType
 6     - Add field user_type to userinfo
 7 bogon:django_modes01 zk$ python3 manage.py migrate
 8 Operations to perform:
 9   Apply all migrations: admin, app01, auth, contenttypes, sessions
10 Running migrations:
11   Rendering model states... DONE
12   Applying contenttypes.0001_initial... OK
13   Applying auth.0001_initial... OK
14   Applying admin.0001_initial... OK
15   Applying admin.0002_logentry_remove_auto_add... OK
16   Applying app01.0001_initial... OK
17   Applying contenttypes.0002_remove_content_type_name... OK
18   Applying auth.0002_alter_permission_name_max_length... OK
19   Applying auth.0003_alter_user_email_max_length... OK
20   Applying auth.0004_alter_user_username_opts... OK
21   Applying auth.0005_alter_user_last_login_null... OK
22   Applying auth.0006_require_contenttypes_0002... OK
23   Applying auth.0007_alter_validators_add_error_messages... OK
24   Applying auth.0008_alter_user_username_max_length... OK
25   Applying sessions.0001_initial... OK

状态

如果提示：No changes detected
需要在settings.py的配置文件检测一下有没有注册app

在MySQL中就可以看到生成的表：

外键关系：

3.开始创建数据

创建数据的时候有两种方式：

第一种方式：

obj = models.表名(字段名='***')
obj.save()

第二种方式： 

models.表名.objects.create(字段名='***')

在views.py中写入数据： 

from django.shortcuts import render,HttpResponse
from app01 import models
 
# Create your views here.
 
def index(request):
    # 创建用户类型表
    models.UserType.objects.create(caption='管路员')
    models.UserType.objects.create(caption='普通用户')
    models.UserType.objects.create(caption='超级管理员')
 
    # 创建用户信息表
    user_info_dict_1 = {'user': 'ales',
                      'email': 'alex@qq.com',
                      'pwd': 123,
                      'user_type': models.UserType.objects.get(nid=1),
                      }
 
    user_info_dict_2 = {'user': 'eric',
                      'email': 'eric@qq.com',
                      'pwd': 123,
                      'user_type_id': 2,
                      }
 
    models.UserInfo.objects.create(**user_info_dict_1)
    models.UserInfo.objects.create(**user_info_dict_2)
    print('yes')
 
    return HttpResponse('ok')

运行Django 项目访问指定文件创建数据：

4、了不起的双下划线之外键正向查找和基本操作 

     # 增
      #
      # models.Tb1.objects.create(c1='xx', c2='oo')  增加一条数据，可以接受字典类型数据 **kwargs
  
      # obj = models.Tb1(c1='xx', c2='oo')
      # obj.save()
  
      # 查
      #
     # models.Tb1.objects.get(id=123)         # 获取单条数据，不存在则报错（不建议）
    # models.Tb1.objects.all()               # 获取全部
     # models.Tb1.objects.filter(name='seven') # 获取指定条件的数据
 
     # 删
     #
     # models.Tb1.objects.filter(name='seven').delete() # 删除指定条件的数据
 
     # 改
     # models.Tb1.objects.filter(name='seven').update(gender='0')  # 将指定条件的数据更新，均支持 **kwargs
     # obj = models.Tb1.objects.get(id=1)
     # obj.c1 = '111'
     # obj.save()                                                 # 修改单条数据

基本操作
 # 获取个数
      #
      # models.Tb1.objects.filter(name='seven').count()
  
      # 大于，小于
      #
     # models.Tb1.objects.filter(id__gt=1)              # 获取id大于1的值
      # models.Tb1.objects.filter(id__lt=10)             # 获取id小于10的值
      # models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 获取id大于1 且 小于10的值
 
     # in
     #
     # models.Tb1.objects.filter(id__in=[11, 22, 33])   # 获取id等于11、22、33的数据
     # models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in
 
     # contains
     #
     # models.Tb1.objects.filter(name__contains="ven")
     # models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感
     # models.Tb1.objects.exclude(name__icontains="ven")
 
     # range
     #
     # models.Tb1.objects.filter(id__range=[1, 2])   # 范围bettwen and
 
     # 其他类似
     #
     # startswith，istartswith, endswith, iendswith,
 
     # order by
     #
     # models.Tb1.objects.filter(name='seven').order_by('id')    # asc
     # models.Tb1.objects.filter(name='seven').order_by('-id')   # desc
 
     # limit 、offset
     #
     # models.Tb1.objects.all()[10:20]
 
     # group by
     from django.db.models import Count, Min, Max, Sum
     # models.Tb1.objects.filter(c1=1).values('id').annotate(c=Count('num'))
     # SELECT "app01_tb1"."id", COUNT("app01_tb1"."num") AS "c" FROM "app01_tb1" WHERE "app01_tb1"."c1" = 1 GROUP BY "app01_tb1"."id"

进阶操作（双下划线）
  •  查

单表查询：

# ret = models.UserType.objects.all()
# print(ret.query)   
# ret.query后台返回的是查询的sql语句

结果： 

SELECT `app01_usertype`.`nid`, `app01_usertype`.`caption` FROM `app01_usertype`

获取查询结果的类型： 

ret = models.UserType.objects.all()
print(type(ret), ret)

可以看到类型是一个QuerySet类型，后面是所有的对象，每一个元素就是一个对象，可以循环拿出每一次的数据： 

ret = models.UserType.objects.all()
    print(type(ret), ret)
 
    for item in ret:
        print(item)

其结果就是每一次循环出来的结果的对象： 

UserType object
UserType object
UserType object

每一个对象都代表一个数据，要出去这些数据如下： 

ret = models.UserType.objects.all()
    print(type(ret), ret)
 
    for item in ret:
        print(item, item.nid, item.caption)

取出的结果： 

UserType object 1 管路员
UserType object 2 普通用户
UserType object 3 超级管理员

   从结果看出每次输出item的时候都是一个对象(一行数据中所有的对象，对象中封装了所有的数据)，在modes中有__str__方法（返回什么，就输出什么，就是查看方便）， 在python2.7中叫__unicode__如果在UserType这个类里面使用这个方法： 

class UserType(models.Model):
    nid = models.AutoField(primary_key=True)
    caption = models.CharField(max_length=16)
 
    def __str__(self):
        return '%s-%s' % (self.nid, self.caption)

然后重新访问下： 

1-管路员 1 管路员
2-普通用户 2 普通用户
3-超级管理员 3 超级管理员

就可以看到每一个对象都看到了返回的相对应的参数了。

　　查询单个字段：

ret = models.UserType.objects.all().values('nid')
print(type(ret), ret)

结果查询出nid字段对应的所有的数据 ： 

<QuerySet [{'nid': 1}, {'nid': 2}, {'nid': 3}]>

可以看查询的sql语句，用query方法： 

ret = models.UserType.objects.all().values('nid')
print(type(ret), ret.query)

查询的结果： 

 SELECT `app01_usertype`.`nid` FROM `app01_usertype`

当通过values循环取值的时候，如下： 

ret = models.UserType.objects.all().values('nid')
    print(type(ret), ret.query)
    for item in ret:
        print(item, type(item))

结果： 

SELECT `app01_usertype`.`nid` FROM `app01_usertype`{'nid': 1} <class'dict'>{'nid': 2} <class'dict'>{'nid': 3} <class'dict'>

通过结果可以看出，最外部是QuerySet，内部元素封装了一个是封装了这一行所有数据的对象，另外只拿到了某几列的字典！

当通过values_list循环取值的时候，如下：

ret = models.UserType.objects.all().values_list('nid')
    print(type(ret), ret)

查询结果： 

<QuerySet [(1,), (2,), (3,)]>

依然是queryset，但是结果就是列表中包含的元组，values和values_list的区别就是：values取的是字典类型，values_list把内部元素变成元组了。通过for循环更直观，如下： 

ret = models.UserType.objects.all().values_list('nid')
    print(type(ret), ret)
    for item in ret:
        print(type(item), item)

发布于

conda channel的镜像设置（设置可用清华源）

文章转自：https://blog.csdn.net/weixin_39278265/article/details/84782550

前言
今天在下载OpenCV的时候发现清华的conda channel镜像已经不能用了，故在此记录：
1）如何显示所有channel；
2）如何更换channel。

1 显示所有channel
首先，conda config –show能够显示出所有conda的config信息。

如果我们只想看channels的信息，输入conda config –show channels即可，如下：

(base) C:\Users\dehen>conda config --show channels
channels:
  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge/
  - defaults

现在我们有两个源，一个清华镜像，一个defauls默认下载源。

然而这个清华源已经不能用了，我在下载opencv的时候，输入：conda install opencv，但是报错：

(base) C:\Users\dehen>conda install opencv
Solving environment: failed

CondaHTTPError: HTTP 000 CONNECTION FAILED for url https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge/win-64/repodata.json
Elapsed: –

An HTTP error occurred when trying to retrieve this URL.
HTTP errors are often intermittent, and a simple retry will get you on your way.
ConnectionError(ReadTimeoutError(“HTTPSConnectionPool(host=’mirrors.tuna.tsinghua.edu.cn’, port=443): Read timed out.”))

所以我打算删除这个源。

2 移除清华镜像
输入：conda config –remove channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge/
这个命令是为了移除之前conda config –show channels显示的清华源。

(base) C:\Users\dehen>conda config --remove channels  https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge/

(base) C:\Users\dehen>conda config --show channels
channels:
  - defaults

(base) C:\Users\dehen>

这时候再运行conda config –show channels会发现清华源已经被删除了

3 添加可用的清华源
参考[4]，我发现自己之前安装的清华源的地址https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge/ 是清华维护的conda三方源之一conda-forge的镜像，，，此外清华还有很多可用的源。

所以我根据官网指示进行了添加：

conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/
conda config --set show_channel_urls yes

conda config –set show_channel_urls yes的意思是从channel中安装包时显示channel的url，这样就可以知道包的安装来源了。

4 下载opencv
在添加好这个源（channel）之后，我重新运行conda install opencv，果然能够成功下载！！！

但是中间竟然是自动安装，在安装前的确认[Y/N]的时候，conda直接跳过了，默认是Y。。。

这让我非常难受，所以我运行了：
conda config –set always_yes false
（这里的意思是安装确认中，不默认yes，而是由我来决定）

5 一些其他的conda指令
conda install <包名> 安装指定包
conda remove <包名> 移除指定包
conda update <包名> 更新指定包

参考文献
[1] Annaconda 增加删除镜像 channel, 以及其他python包安装解决办法 https://blog.csdn.net/mtj66/article/details/57074986

最开始是看到这里的评论，发现清华的源用不了。
[2] conda常用命令详解 https://www.jianshu.com/p/484cfbf45ed3

在这里学到了一些conda的命令
[3] [加速]为conda添加国内镜像 https://www.aliyun.com/jiaocheng/459144.html

在这里发现原来我之前添加的清华源，和真正的清华源不一样，这促使我进一步寻找可用的清华源。
[4] Anaconda 镜像使用帮助 https://mirrors.tuna.tsinghua.edu.cn/help/anaconda/

这里是清华源的官网，我找到了可用的清华源并进行了安装。

发布于

答题卡识别项目实战

答题卡识别效果

在这里插入图片描述
【大致思路】：先进行仿射变换去除背景（只留试卷部分），二值化，圆形轮廓检测，遍历每一行选项，统计非零像素，记录填充选项（即非零像素最多的轮廓区域），与正确答案进行比对，正确则correct数+1，得到总成绩
1-4 基础操作+透视变换

1-4是基础操作, 3是做近似变换, 取最大的那个轮廓,最有可能是图像最大外围的轮廓

3的近似变换 和 4的透视变换原理 可以参考我的 OCR文档扫描实战

# 1.预处理
image = cv2.imread(args["image"])
contours_img = image.copy()
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
blurred = cv2.GaussianBlur(gray, (5, 5), 0)
cv_show('blurred',blurred)
edged = cv2.Canny(blurred, 75, 200)
cv_show('edged',edged)

# 2.轮廓检测
cnts = cv2.findContours(edged.copy(), cv2.RETR_EXTERNAL,
	cv2.CHAIN_APPROX_SIMPLE)[1]
cv2.drawContours(contours_img,cnts,-1,(0,0,255),3) 
cv_show('contours_img',contours_img)
docCnt = None

# 3.确保检测到了
if len(cnts) > 0:
	# 根据轮廓大小进行排序
	cnts = sorted(cnts, key=cv2.contourArea, reverse=True)

	# 遍历每一个轮廓
	for c in cnts:
		# 近似
		peri = cv2.arcLength(c, True)
		approx = cv2.approxPolyDP(c, 0.02 * peri, True)

		# 准备做透视变换
		if len(approx) == 4:
			docCnt = approx
			break

# 4.执行透视变换
warped = four_point_transform(gray, docCnt.reshape(4, 2))
cv_show('warped',warped)
在这里插入图片描述

5-6 阈值处理+轮廓检测

5.Otsu’s 阈值处理
THRESH_OTSU会自动寻找合适的阈值，适合双峰，需把阈值参数设置为0
在我的信用卡数字识别案例中出现也有应用(第三、五部分)

在这里插入图片描述

6.然后怎么区分涂和没涂的圆？
这里不用霍夫变换,因为有些涂完后 会突出边界，如下

# 5.Otsu's 阈值处理
thresh = cv2.threshold(warped, 0, 255,
	cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1] 
cv_show('thresh',thresh)

thresh_Contours = thresh.copy()
# 6.找到每一个圆圈轮廓
cnts = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL,
	cv2.CHAIN_APPROX_SIMPLE)[1]
cv2.drawContours(thresh_Contours,cnts,-1,(0,0,255),3) 
cv_show('thresh_Contours',thresh_Contours)
questionCnts = []
在这里插入图片描述

7-8 筛选答题圈

7.遍历所有圆圈轮廓(包括干扰项) 筛选出答题区域的圆,其轮廓存于questionCnts
无论是圆形还是矩形的答题卡,都是规则的形状,比例相同.
所以这里要人工设定圆圈外接矩形的长宽比例
参考信用卡数字识别 (第四部分)

8.按照从上到下(从左到右)进行排序
参考信用卡数字识别 (第二部分)

# 7.遍历所有圆圈轮廓(包括干扰项) 筛选出答题区域的圆
for c in cnts:
	# 计算比例和大小
	(x, y, w, h) = cv2.boundingRect(c)
	ar = w / float(h)

	# 根据实际情况指定标准	-- 过滤操作
	if w >= 20 and h >= 20 and ar >= 0.9 and ar <= 1.1:
		questionCnts.append(c)

# 8.按照从上到下进行排序
questionCnts = sort_contours(questionCnts,
	method="top-to-bottom")[0]
correct = 0

9.每行的5个选项 分别比对正确答案

答题圈的轮廓questionCnts长度应为25, 间隔5, 可以遍历5次, 则
q 取0 1 2 3 4,共5行;
i 表示从第几个轮廓开始:0,5,10,15,20. 即每行的第一个轮廓

9.每行的5个选项 分别比对正确答案

for (q, i) in enumerate(np.arange(0, len(questionCnts), 5)):
# 9.1排序
cnts = sort_contours(questionCnts[i:i + 5])[0]
bubbled = None

# 9.2 遍历每一个结果
for (j, c) in enumerate(cnts):
    # 9.2.1 使用mask来判断结果
    mask = np.zeros(thresh.shape, dtype="uint8")
    cv2.drawContours(mask, [c], -1, 255, -1) #-1表示填充
    cv_show('mask',mask)
    # 9.2.2 通过计算非零点数量来算是否选择这个答案
    mask = cv2.bitwise_and(thresh, thresh, mask=mask)
    total = cv2.countNonZero(mask)

    # 9.2.3 通过阈值判断
    if bubbled is None or total > bubbled[0]:
        bubbled = (total, j)

# 9.3 获取正确答案
color = (0, 0, 255)
k = ANSWER_KEY[q]

# 9.4 对比答案 并 判断正确
if k == bubbled[1]:
    color = (0, 255, 0)
    correct += 1

# 9.5 绘图
cv2.drawContours(warped, [cnts[k]], -1, color, 3)

9.1 确保每一行的顺序为A B C D E
9.2 同样这么一行里,这5个框有什么不同.

j 取每个选项0 1 2 3 4
9.2.1 使用mask来判断结果

初始化一个 跟透视变换后的图 一样大小的mask(全黑)
然后在mask上, 画出当前遍历的这个(圆圈)轮廓c, 画成白色

cv2.drawContours (传入绘制图像,轮廓,轮廓索引,颜色模式,线条厚度)
参考OpenCV基本操作
补充一点：线条厚度 为负值或CV_FILLED 表示填充轮廓内部

一行遍历5个选项，5行一共25个选项，这展示前两行的遍历结果，后三行同理…

在这里插入图片描述

9.2.2 与操作

一张图片 跟 一张相同大小的黑白图片 进行与操作,则只保留图片的白色区域

cv2.bitwise_and(src1, src2, dst=None, mask=None)
对图像(灰度图像或彩色图像均可)每个像素值进行二进制“与”操作,
1&1=1，1&0=0，0&1=0，0&0=0

函数返回值： 调用时若无mask参数 则返回src1 & src2，若存在mask参数，则返回src1 & src2 & mask

    src1：输入原图1
    src2：输入原图2, src1与src2可以相同也可以不相同,可以是灰度图像也可以是彩色图像
    dst：输出矩阵,和输入矩阵一样的尺寸和类型 若存在参数时：src1 & src2 或者 src1 & src2 & mask
    mask：可以是单通道8bit灰度图像,也可以是矩阵,一般为二值化后的图像,指定要更改的输出数组的元素

cv2.countNonZero统计非零像素点个数

9.2.3 依次判断5个选项的哪个非零值最大(即哪个被填充上了)

total > bubbled[0] 比它大的才保留到bubbled
bubbled 保留最大的选项( 即填充上的选项 ) j
9.3 k = ANSWER_KEY[q] 是第几题(行)的正确答案
9.4 若k = bubbled[1]，判断正确，correct+=1

.
10.打印正确率

# 10.打印正确率
score = (correct / 5.0) * 100
print("[INFO] score: {:.2f}%".format(score))
cv2.putText(warped, "{:.2f}%".format(score), (10, 30),
	cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
cv2.imshow("Original", image)
cv2.imshow("Exam", warped)
cv2.waitKey(0)
在这里插入图片描述

* 测试其他答题卡效果

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

结束语

虽然代码有点长，但大部分内容都是前面几个项目有用到的知识。可见遇到不同场景的举一反三能力多重要啦

扩展

有兴趣的同学们 可以尝试一下矩形答题卡的识别

完整代码

一个py文件，3个函数

# 导入工具包
import numpy as np
import argparse
import cv2
def order_points(pts):
	# 一共4个坐标点
	rect = np.zeros((4, 2), dtype = "float32")

	# 按顺序找到对应坐标0123分别是 左上，右上，右下，左下
	# 计算左上，右下
	s = pts.sum(axis = 1)
	rect[0] = pts[np.argmin(s)]
	rect[2] = pts[np.argmax(s)]

	# 计算右上和左下
	diff = np.diff(pts, axis = 1)
	rect[1] = pts[np.argmin(diff)]
	rect[3] = pts[np.argmax(diff)]

	return rect

def four_point_transform(image, pts):
	# 获取输入坐标点
	rect = order_points(pts)
	(tl, tr, br, bl) = rect

	# 计算输入的w和h值
	widthA = np.sqrt(((br[0] - bl[0]) ** 2) + ((br[1] - bl[1]) ** 2))
	widthB = np.sqrt(((tr[0] - tl[0]) ** 2) + ((tr[1] - tl[1]) ** 2))
	maxWidth = max(int(widthA), int(widthB))

	heightA = np.sqrt(((tr[0] - br[0]) ** 2) + ((tr[1] - br[1]) ** 2))
	heightB = np.sqrt(((tl[0] - bl[0]) ** 2) + ((tl[1] - bl[1]) ** 2))
	maxHeight = max(int(heightA), int(heightB))

	# 变换后对应坐标位置
	dst = np.array([
		[0, 0],
		[maxWidth - 1, 0],
		[maxWidth - 1, maxHeight - 1],
		[0, maxHeight - 1]], dtype = "float32")

	# 计算变换矩阵
	M = cv2.getPerspectiveTransform(rect, dst)
	warped = cv2.warpPerspective(image, M, (maxWidth, maxHeight))

	# 返回变换后结果
	return warped
def sort_contours(cnts, method="left-to-right"):
    reverse = False
    i = 0
    if method == "right-to-left" or method == "bottom-to-top":
        reverse = True
    if method == "top-to-bottom" or method == "bottom-to-top":
        i = 1
    boundingBoxes = [cv2.boundingRect(c) for c in cnts]
    (cnts, boundingBoxes) = zip(*sorted(zip(cnts, boundingBoxes),
                                        key=lambda b: b[1][i], reverse=reverse))
    return cnts, boundingBoxes
def cv_show(name,img):
    cv2.imshow(name, img)
    cv2.waitKey(0)
    cv2.destroyAllWindows()  

'''下面为主函数'''
if __name__ == "__main__":
	# 设置参数
	ap = argparse.ArgumentParser()
	ap.add_argument("-i", "--image", required=True,
		help="path to the input image")
	args = vars(ap.parse_args())

	# 正确答案
	ANSWER_KEY = {0: 1, 1: 4, 2: 0, 3: 3, 4: 1}

	# 1.预处理
	image = cv2.imread(args["image"])
	contours_img = image.copy()
	gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
	blurred = cv2.GaussianBlur(gray, (5, 5), 0)
	cv_show('blurred',blurred)
	edged = cv2.Canny(blurred, 75, 200)
	cv_show('edged',edged)

	# 2.轮廓检测
	cnts = cv2.findContours(edged.copy(), cv2.RETR_EXTERNAL,
		cv2.CHAIN_APPROX_SIMPLE)[1]
	cv2.drawContours(contours_img,cnts,-1,(0,0,255),3) 
	cv_show('contours_img',contours_img)
	docCnt = None

	# 3.确保检测到了
	if len(cnts) > 0:
		# 根据轮廓大小进行排序
		cnts = sorted(cnts, key=cv2.contourArea, reverse=True)

		# 遍历每一个轮廓
		for c in cnts:
			# 近似
			peri = cv2.arcLength(c, True)
			approx = cv2.approxPolyDP(c, 0.02 * peri, True)

			# 准备做透视变换
			if len(approx) == 4:
				docCnt = approx
				break

	# 4.执行透视变换
	warped = four_point_transform(gray, docCnt.reshape(4, 2))
	cv_show('warped',warped)
	# 5.Otsu's 阈值处理
	thresh = cv2.threshold(warped, 0, 255,
		cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1] 
	cv_show('thresh',thresh)

	thresh_Contours = thresh.copy()
	# 6.找到所有轮廓
	cnts = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL,
		cv2.CHAIN_APPROX_SIMPLE)[1]
	cv2.drawContours(thresh_Contours,cnts,-1,(0,0,255),3) 
	cv_show('thresh_Contours',thresh_Contours)
	questionCnts = []

	# 7.遍历所有圆圈轮廓(包括干扰项) 筛选出答题区域的圆
	for c in cnts:
		# 计算比例和大小
		(x, y, w, h) = cv2.boundingRect(c)
		ar = w / float(h)

		# 根据实际情况指定标准	-- 过滤操作
		if w >= 20 and h >= 20 and ar >= 0.9 and ar <= 1.1:
			questionCnts.append(c)

	# 8.按照从上到下进行排序
	questionCnts = sort_contours(questionCnts,
		method="top-to-bottom")[0]
	correct = 0

	# 9.每行的5个选项 分别比对正确答案
	for (q, i) in enumerate(np.arange(0, len(questionCnts), 5)):
		# 9.1排序
		cnts = sort_contours(questionCnts[i:i + 5])[0]
		bubbled = None

		# 9.2 遍历每一个结果
		for (j, c) in enumerate(cnts):
			# 9.2.1 使用mask来判断结果
			mask = np.zeros(thresh.shape, dtype="uint8")
			cv2.drawContours(mask, [c], -1, 255, -1) #-1表示填充
			# cv_show('mask',mask)
			# 9.2.2 通过计算非零点数量来算是否选择这个答案
			mask = cv2.bitwise_and(thresh, thresh, mask=mask)
			total = cv2.countNonZero(mask)

			# 9.2.3 通过阈值判断
			if bubbled is None or total > bubbled[0]:
				bubbled = (total, j)

		# 9.3 获取正确答案
		color = (0, 0, 255)
		k = ANSWER_KEY[q]

		# 9.4 对比答案 并 判断正确
		if k == bubbled[1]:
			color = (0, 255, 0)
			correct += 1

		# 9.5 绘图
		cv2.drawContours(warped, [cnts[k]], -1, color, 3)

	# 10.打印正确率
	score = (correct / 5.0) * 100
	print("[INFO] score: {:.2f}%".format(score))
	cv2.putText(warped, "{:.2f}%".format(score), (10, 30),
		cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
	cv2.imshow("Original", image)
	cv2.imshow("Exam", warped)
	cv2.waitKey(0)
————————————————
版权声明：本文为CSDN博主「龙共日尧」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/sinat_29950703/article/details/108287249

相关文章收藏：

利用Python+opencv+TensorFlow框架打造 一个试卷批改系统

Python+OpenCV+PyQt开发答题卡识别软件源码

计算机视觉OpenCV答题卡识别项目实战

发布于

python爬取试题信息-保存文本并利用正则表达式获取指定字段并保存mysql数据库

原文链接：https://blog.csdn.net/weixin_44648900/article/details/105196981

疫情期间无聊突发奇想想要做一个在线考试系统，目前已完成数据库设计，开始编写爬虫爬取试题数据，目标网站如下，获取内容包括：考点，试题，答案选项，答案，解析。考点字段的获取便于以后系统个性化推荐的需要。🚔

在这里插入图片描述
在这里插入图片描述

去除网页里获取时候遇到的脏数据

查看网页的时候发现这个东西，可能是他们后台有其他用途，由于直接匹配字段不方便，先把所有网页文本先获取再把class为this_jammer等中内容获取为停用词表，爬取的试题文本去掉这些脏数据就OK了。

在这里插入图片描述

下面保存脏数据表的函数

在这里插入图片描述
#-*-coding:utf-8-*-
import requests
from bs4 import BeautifulSoup
# import codecs
def get_url(target_url, server, headers):
    req = requests.get(target_url, headers=headers)
    bf = BeautifulSoup(req.text)
    div = bf.find_all('div', class_='questions_col')
    a_bf = BeautifulSoup(str(div[0]))
    a = a_bf.find_all('a')
    cheak_parsing_url = []
    for each in a:
        if each.string == "查看解析":
            full_url = server + each.get('href')
            cheak_parsing_url.append(full_url)
    print(cheak_parsing_url)
    return cheak_parsing_url

def change_page(target_url, server, headers):
    req = requests.get(target_url, headers=headers)
    bf = BeautifulSoup(req.text)
    div = bf.find_all('div', class_='fenye')
    a_bf = BeautifulSoup(str(div[0]))
    a = a_bf.find_all('a')
    full_url = None
    for each in a:
        if each.string == "下一页":
            full_url = server + each.get('href')
            print(full_url)
        else :
            continue
    return full_url

def get_html(url_list, file_path, headers):
    for url in url_list:
        req = requests.get(url, headers=headers)
        content = req.content.decode('utf-8','ignore')
        bf = BeautifulSoup(content, fromEncoding="gb18030")
        del_text = bf.find_all(class_=["this_jammer", "hidejammersa", "jammerd42"])
        for i in del_text:
            if i:
                new_tag = ""
                try:
                    i.string.replace_with(new_tag)
                except:
                    pass
        texts = bf.find_all('div', class_= 'answer_detail')
        try:
            texts = texts[0].text.replace('\xa0', '')
            texts = texts.replace(" ", "")
        except:
            pass
        try:
            texts = texts.replace("\n", '')
        except:
            pass
        print(texts)
        contents_save(file_path, texts)

def contents_save(file_path, content):
    """
    :param file_path: 爬取文件保存路径
    :param content: 爬取文本文件内容
    :return: None
    """
    with open(file_path, 'a', encoding="utf-8", errors='ignore') as f:
        try:
            f.write(content)
        except:
            pass
        f.write('\n')

def get_category(target_url, server, headers):
    req = requests.get(target_url, headers=headers)
    bf = BeautifulSoup(req.text)
    div = bf.find_all('div', class_='shiti_catagory frame')
    a_bf = BeautifulSoup(str(div[0]))
    a = a_bf.find_all('a')
    category = []
    for each in a:
        full_url = server + each.get('href')
        category.append(full_url)
    print(category)
    return category

if __name__ == "__main__":
    main_url = "https://tiku.21cnjy.com/tiku.php?mod=quest&channel=8&xd=3"
    server = "https://tiku.21cnjy.com/"
    save_dir = "/Users/lidongliang/Desktop/爬虫/data"
    subject_file = "1.txt"
    file_path = save_dir + '/' + subject_file
    headers = {
        'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.132 Safari/537.36',
        'Accept-Encoding': 'gzip'}
    categorys = get_category(main_url, server, headers)
    for category_url in categorys:
        counting = 0
        target_url = category_url
        while counting < 100:
            cheak_parsing_url = get_url(target_url, server, headers)
            get_html(cheak_parsing_url, file_path, headers)
            target_url = change_page(target_url, server, headers)

            if target_url == None:
                break
            counting += 1

运行初步结果如下：

在这里插入图片描述

对文本进行正则匹配获取文本指定字段并保存到数据库

import re
import pymysql

w1 = 'A．'
w2 = 'B．'
w3 = 'C．'
w4 = 'D．'
w5 = '答案'
w6 = '解析试题分析：'
w7 = '考点'


def get_txt():
    with open("/Users/lidongliang/Desktop/爬虫/data/1.txt", "r") as f:
        txt = f.readlines()
        return txt


def fen(txt):
    # buff = txt.replace('\n','')
    timu = re.compile('^' + '(.*?)' + w1, re.S).findall(txt)
    A = re.compile(w1 + '(.*?)' + w2, re.S).findall(txt)
    B = re.compile(w2 + '(.*?)' + w3, re.S).findall(txt)
    C = re.compile(w3 + '(.*?)' + w4, re.S).findall(txt)
    D = re.compile(w4 + '(.*?)' + w5, re.S).findall(txt)
    daan = re.compile(w5 + '(.*?)' + w6, re.S).findall(txt)
    jiexi = re.compile(w6 + '(.*?)' + w7, re.S).findall(txt)
    kaodian = re.compile(w7 + '(.*?)' + '\Z', re.S).findall(txt)

    timu.extend(A)
    timu.extend(B)
    timu.extend(C)
    timu.extend(D)
    timu.extend(daan)
    timu.extend(jiexi)
    timu.extend(kaodian)

    # print(timu)

    try:
        tg = timu[0]
        xx = ("A:" + timu[1] + "B:" + timu[2] + "C:" + timu[3] + "D:" + timu[4])
        da = timu[5]
        fx = timu[6]
        kd = timu[7]
    except:
        tg = '1'
        xx = '1'
        da = '1'
        fx = '1'
        kd = '1'
    con = pymysql.connect(host='localhost', user='root', passwd='00000000', db='login_test_1', charset='utf8')
    cursor = con.cursor()
    sql = "insert into question_info(tg,xx,da,fx,kd) values('%s','%s','%s','%s','%s')" \
          % (tg, xx, da, fx, kd)
    cursor.execute(sql)
    con.commit()


if __name__ == "__main__":
    txt = get_txt()
    for i in txt:
        fen(i)
    print("done")

最后结果：

在这里插入图片描述