【教学类-52-06】20240422动物数独（6宫格） 打印版

已于 2024-04-23 17:59:57 修改
阅读量1k 收藏 19
点赞数 34
分类专栏： Python 文章标签： python
于 2024-04-23 17:57:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/reasonsummer/article/details/138130758
版权

作品展示

背景需求：

中班区角检查，我在中六班看到一个墙面上的四宫格数独

我感觉这个是购买的，TB一搜，果然是万能的TB！

看了孩子的操作过程：

1、根据手掌大的图卡的图案排列位置，在背景板上先将已经有的图案（大卡片）贴在背景板上

2、在墙上推算空格上的图案是什么。

这种网络的数独样板优势：

1、只需要提供16张动物图案大卡片，在墙面上操作

2、关卡图片做的很小，只是用来参考摆放位置的

我觉得这种样式，裁剪纸片的数量。比我原来设计的动物数独四宫格需要30张提供3*48=144张卡片要省力的多。

【教学类-52-04】20240412动物数独（4宫格）空1-空15-CSDN博客文章浏览阅读454次，点赞14次，收藏10次。【教学类-52-04】20240412动物数独（4宫格）空1-空15https://blog.csdn.net/reasonsummer/article/details/137698146

正好，一起参观的大5班老师（我以前的搭档）问我：

“你们班那个数独能给我们一份吗？大班下个月检查，也是动物主题。”

“没问题，可以用python做，但是大班做4个动物有点简单啊！”

“那就6个动物好了！”她说。

破解难点：

一、排序规律

1、4宫格有横向、纵向、小四格不重复的三重规律

【教学类-43-20】20240113 数独（二）4宫格、9宫格 无空行A4模板_数独空白表格a4-CSDN博客文章浏览阅读755次，点赞23次，收藏8次。【教学类-43-20】20240113 数独（二）4宫格、9宫格 无空行A4模板_数独空白表格a4https://blog.csdn.net/reasonsummer/article/details/135573374

2、6宫格只有横向和纵向不重复的规律

【教学类-43-19】20240113 数独（一） 3-5-6-7-8-10宫格 无空行A4模板_10宫格数独图片-CSDN博客文章浏览阅读702次，点赞16次，收藏11次。【教学类-43-19】20240113 数独（一） 3-5-6-7-8-10宫格 无空行A4模板_10宫格数独图片https://blog.csdn.net/reasonsummer/article/details/135572966

二、数独底图缩小

1、随机生成的数独底图需要缩小成10*10CM，便于A4一页6张图。但是直接生成底图时，只能1个关卡图。不能混合插入1-6关的图纸

2、尝试将每一个关卡图的pdf转png,以图片方式将关卡图插入A4模板里。

三、动物大图卡

动物图片从3.2CM一张变成9.84CM一张

图片准备：

WORD模板

1、做数独底图的模板

2、6个关卡一张A4的模板

3、制作动物大图卡的模板

代码展示：

# 测试11*11格，2*2一共4套3*3 宫格
'''
动物数独 6宫格，

1、大卡片9.84CM一行，A4一页6张
2、参考图（空1格到空36格子，生成PDF，转为png
3、将png关卡图片做成8.82*9.7的小图卡（A4一页6张)
4、图片卡和关卡图合并在一个PDF


时间：2024年4月12日
作者：「Vaeeeeeee」，AI对话大师，阿夏
时间：2024年4月12日 13:35






'''



print('-----0、生成大图片卡-------')

    
# -*- coding:utf-8 -*-

'''
制作动物数独的黏贴卡片 A4一页6张图片 9.85CM
作者：AI对话大师，阿夏
时间：2024年4月11日
# '''

# print('----1、读取行列-------')
from docx import Document
from docx.shared import Cm
import os

path=r'C:\Users\jg2yXRZ\OneDrive\桌面\动物数独6宫格'

# # 新建一个”装N份word和PDF“的临时文件夹
imagePath=path+r'\\零时Word'
os.makedirs(imagePath,exist_ok=True)  # 若图片文件夹不存在就创建

imagePath3=path+r'\\汇总'
os.makedirs(imagePath3,exist_ok=True) 
# 打开.docx文件

doc = Document(path +r'\动物数独（6宫格竖版）大卡片.docx')

# 获取文档中的所有表格
tables = doc.tables

# 选择你需要读取的表格（在这种情况下是第1张表格）
target_table = tables[0]

# 获取所选表格的行数和列数
num_rows = len(target_table.rows)
num_columns = len(target_table.columns)

print("行数:", num_rows)
# 3
print("列数:", num_columns)
# 2



# # 测算4类图片每种几张
# sum=int(num_rows*num_columns)
# print(sum)
# 

print('----2、生成足够数量的图片-------')

import os

# 指定文件夹路径
folder_path =path+r'\02动物图片'

# 读取文件夹中所有文件的名称并加上路径
file_paths = [os.path.join(root, file) for root, dirs, files in os.walk(folder_path) for file in files]
print(file_paths)
file_paths=file_paths
pic_list=[]
# 打印文件名称和路径
for file_path in file_paths:
    # for i in range(sum):
    pic_list.append(file_path)
print(pic_list)
print(len(pic_list))
# # 5



print('----3、插入图片-------')
for f in range(6):
# 打开.docx文件
    doc = Document(path+r'\动物数独（6宫格竖版）大卡片.docx')

    # 获取文档中的所有表格
    tables = doc.tables

    # 获取第一个表格
    table = tables[0]
    
    # 遍历表格的所有行和单元格
    i = 0
    for row in table.rows:
        for cell in row.cells:
            # 在单元格中插入图片
            cell_paragraph = cell.paragraphs[0]
            run = cell_paragraph.add_run()
            run.add_picture(pic_list[i], width=Cm(9.84), height=Cm(9.84))
            cell_paragraph.alignment = 1  # 设置单元格中的文本居中
            i += 1  # 移动到下一个图片路径

    # 保存修改后的.docx文件
    doc.save(imagePath + fr'\动物数独卡片{f:02d}页.docx')
    from docx2pdf import convert
    # docx 文件另存为PDF文件
    inputFile =imagePath + fr'\动物数独卡片{f:02d}页.docx'# 要转换的文件：已存在
    outputFile = imagePath + fr'\动物数独卡片{f:02d}页.pdf' # 要生成的文件：不存在
    # 先创建 不存在的 文件
    f1 = open(outputFile,'w')
    f1.close()
    # 再转换往PDF中写入内容
    convert(inputFile, outputFile)

    from docx2pdf import convert


    
import os
from PyPDF2 import PdfMerger

pdf_lst = [f for f in os.listdir(imagePath) if f.endswith('.pdf')]
pdf_lst = [os.path.join(imagePath, filename) for filename in pdf_lst]
pdf_lst.sort()
file_merger = PdfMerger()
for pdf in pdf_lst:
    print(pdf)
    file_merger.append(pdf)

file_merger.write(imagePath3+r"\（打印合集)动物数独6宫格9.84CM大卡片.pdf")
file_merger.close()
# doc.Close()

# # print('----------第5步：删除临时文件夹------------')    
import shutil
shutil.rmtree(imagePath) #递归删除文件夹，即：删除非空文件夹

import random,time
from win32com.client import constants,gencache
from win32com.client.gencache import EnsureDispatch
from win32com.client import constants # 导入枚举常数模块
import os,time

import docx
from docx import Document
from docx.shared import Pt 
from docx.shared import RGBColor
from docx.enum.text import WD_PARAGRAPH_ALIGNMENT
from docx.oxml.ns import qn


from docxtpl import DocxTemplate
import pandas as pd
from docx2pdf import convert
from docx.shared import RGBColor

from docx import Document
from docx.shared import Cm
from docx.enum.text import WD_ALIGN_PARAGRAPH, WD_PARAGRAPH_ALIGNMENT



from docx.oxml.ns import nsdecls
from docx.oxml import parse_xml


# 生成题库
import random
import copy


num=1
# int(input('生成几份\n'))
# 制作"单元格"# 几宫格
hsall=6
# int(input('请输入4或9\n'))
hs=hsall

# kk=int(input('空格数量，输入5，就是50%，就是空一半）\n'))

print('------1、如果正好想生成1空、2空、3空、4空的数字，需要测算百分比的具体数字------')

n=hsall
g=n*n

a=[]
for i in range(1,101):
    # 因为有100，所以三位数
    
    print(f'{n}宫格，难度{i:03d},抽取{i:03d}%:实际有{int(g*i/100):03d}空,已有图案{g-int(g*i/100):03d}')
    a.append(f'{n}宫格，难度{i:03d},抽取{i:03d}%:实际有{int(g*i/100):03d}空,已有图案{g-int(g*i/100):03d}')
print(a)
print(len(a))
# # 用冒号分割，如果0空，加入，

# 创建一个空列表用于存储匹配的元素
b = []

# 遍历原始列表
for element in a:
    # 如果找到匹配的元素，以":"为分隔符将字符串分割成两部分
    parts = element.split(":")
    # print(parts)
    # # 提取第一部分中包含的数字信息
    info = parts[1]
    b.append(info)
# 对列表b进行排序，并去除重复项
b = list(set(b))
b.sort(reverse=False)
print(b)

f=[]
for d in range(len(b)):
    for c in a:
        # print(c)
        # 读取一个就中断
        if c[-15:]==b[d]:
            f.append(c)
            break
f.pop(0)
# 删除['4宫格，难度01,抽取1%:实际有00空,已有图案16', 
# f.pop(-1)
# # 删除'4宫格，难度100,抽取100%:实际有16空,已有图案00'
print(f)
# ['4宫格，难度007,抽取007%:实际有001空,已有图案015', '4宫格，难度013,抽取013%:实际有002空,已有图案014', '4宫格，难度019,抽取019%:实际有003空,已有图案013', '4宫格，难度025,抽取025%:实际有004空
# ,已有图案012', '4宫格，难度032,抽取032%:实际有005空,已有图案011', '4宫格，难度038,抽取038%:实际有006空,已有图案010', '4宫格，难度044,抽取044%:实际有007空,已有图案009', '4宫格，难度050,抽取050%:实际有008空,已有图案008', '4宫格，难度057,抽取057%:实际有009空,已有图案007', '4宫格，难度063,抽取063%:实际有010空,已有图案006', '4宫格，难度069,抽取069%:实际有011空,已有图案005', '4宫格，
# 难度075,抽取075%:实际有012空,已有图案004', '4宫格，难度082,抽取082%:实际有013空,已有图案003', '4宫格，难度088,抽取088%:实际有014空,已有图案002', '4宫格，难度094,抽取094%:实际有015空,已有图案
# 001']
print(len(f))
# 15
# 难度有15关

# 提取百分数
g=[]
w=[]
for p in f:
    g.append(int(p[12:15]))    # 提取第6-7个数字=百分比数字
    w.append(int(p[20:23]))    # 提取空格数量
print(g)
# [7, 13, 19, 25, 32, 38, 44, 50, 57, 63, 69, 75, 82, 88, 94]
print(len(g))
# 15关
print(w)
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
print(len(w))
# 36


print('------2、制作6宫格随机数字------')


import random
from win32com.client import constants,gencache
from win32com.client.gencache import EnsureDispatch
from win32com.client import constants # 导入枚举常数模块
import os,time

import docx
from docx import Document
from docx.shared import Pt 
from docx.shared import RGBColor
from docx.enum.text import WD_PARAGRAPH_ALIGNMENT
from docx.oxml.ns import qn


from docxtpl import DocxTemplate
import pandas as pd
from docx2pdf import convert
from docx.shared import RGBColor


# 生成题库
import random
import copy


# 制作"单元格"# 几宫格
for kk in range(len(g)):
# hs=int(input('请输入宫格数量（3,5.6,7,8，）\n'))
    
    # 因为有3-9的不同word模板，所以有不同的套数和字体大小
    ll=['6'] # 如果输入345
    mm=['11']# 3对应的套数是4*3套
    nn=['36']# 3对应的写入单元格的数字大小36磅 
    for r in range(len(ll)):
        if hs ==int(ll[r]):
            # 底边几套.底边看有2份
            db=int(mm[r][0])
            # int(input('底边几套? 3\n'))
            # 侧边几套 侧边看也是2份
            print(db )        
            cb=int(mm[r][1])
            # int(input('侧边几套? 2\n'))
            print(cb)
            size=int(nn[r])
            print(size)        # 写入单元格数字的大小（撑满格子）

    path=r'C:\Users\jg2yXRZ\OneDrive\桌面\动物数独6宫格'
    # 新建一个”装N份word和PDF“的临时文件夹
    imagePath=path+r'\\零时Word'
    os.makedirs(imagePath,exist_ok=True) 

    imagePath2=path+r'\\零时jpg'
    os.makedirs(imagePath2,exist_ok=True) 

    imagePath3=path+r'\\汇总'
    os.makedirs(imagePath3,exist_ok=True) 

    # 计算不同模板中的单元格坐标，放在bg里
    # 棋盘格子数量，


    # 如果长方形：底边3*侧边2，3*2=6套 ，就是10*10宫格，底边格子数量就是10*3=30，侧边格子数量就是10*2=20，
    # if db==cb:

    db_size = hs*db
    cb_size=  hs*cb
    print('{}宫格排列底{}侧{}共{}套,底边格子数{}'.format(hs,db,cb,db*cb,db_size ))
    print('{}宫格排列底{}侧{}共{}套,侧边格子数{}'.format(hs,db,cb,db*cb,cb_size ))

    # 确定每个宫格的左上角坐标 00 04 40  44 中间没有分栏的空格了，所以hs不用+1
    bgszm=[]
    for a in range(0,cb_size,hs):    # 0-11每隔4，写一个坐标  侧边y
        for b in range(0,db_size,hs):  # 0-11每隔4，写一个坐标  侧边x
            bgszm.append('{}{}'.format('%02d'%a,'%02d'%b))
    print(bgszm)
    # 10宫格排列底3侧2共6套,底边格子数30
    # 10宫格排列底3侧2共6套,侧边格子数20
    # 10宫格排列底3侧2共6套,侧边格子数20
    # ['0000', '0010', '0020', '1000', '1010', '1020']
        

    # 转为元祖
    start_coordinates = [(int(s[0:2]), int(s[2:4])) for s in bgszm]
    cell_coordinates = []

    # 推算每个起始格子后面的单元格数字
    for start_coord in start_coordinates:
        i, j = start_coord
        subgrid_coordinates = []
        for x in range(hs):
            for y in range(hs):
                subgrid_coordinates.append((i + x, j + y))
        cell_coordinates.append(subgrid_coordinates)

    # 打印结果（元祖样式）
    bg=[]
    for coordinates in cell_coordinates:
        # print(coordinates)     # [(4, 8), (4, 9), (4, 10), (5, 8), (5, 9), (5, 10), (6, 8), (6, 9), (6, 10)]
        for c in  coordinates:
            print(c)        # 元组 (1, 2) 样式
            s = ''.join(str(num).zfill(2) for num in c)   # zfill将元组 (1, 2) 转换为字符串 '0102' 特别是（5,10）这种必须转成2个数字0510
            print(str(s))        #  '12'
            bg.append(s)  #  '0102'
    print(bg)


    # 生成PDf
    P=[] 
    for z in range(num):  
        P.clear()
        #    制作4份数据
        for j in range(db*cb):    #  3宫格，4*3=12套
        
        # ————————————————生成随机宫格，按比例空缺格子
        # 版权声明：本文为CSDN博主「Vaeeeeeee」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
        # 原文链接：https://blog.csdn.net/m0_46366547/article/details/131334720
            def generate_sudoku_board():
                # 函数体生成数独库表盘
                # 创建一个9x9的二维列表，表示数独棋盘
                board = [[0] * hs for _ in range(hs)]

                # 递归函数，用于填充数独棋盘的每个单元格
                def filling_board(row, col):
                    # 检查是否填充完成整个数独棋盘
                    if row == hs:
                        return True
                    
                    # 计算下一个单元格的行和列索引
                    next_row = row if col < hs-1 else row + 1
                    next_col = (col + 1) % hs

                    # 获取当前单元格在小九宫格中的索引
                    box_row = row 
                    box_col = col

                    # 随机生成1到9的数字
                    numbers = random.sample(range(1, hs+1), hs)

                    for num in numbers:
                        # 检查行、列、小九宫格是否已经存在相同的数字
                        if num not in board[row] and all(board[i][col] != num for i in range(hs)) and all(num != board[i][j] for i in range(box_row, box_row) for j in range(box_col, box_col)):
                            board[row][col] = num

                            # 递归填充下一个单元格
                            if filling_board(next_row, next_col):
                                return True

                            # 回溯，将当前单元格重置为0
                            board[row][col] = 0

                    return False

                # 填充数独棋盘
                filling_board(0, 0)
                return board

             # 定量出现空白格子
                      
            def create_board(): # level数字越大代表游戏难度越大
                """
                生成一个随机的数独棋盘,空白格少
                """
                board = generate_sudoku_board()
                board1 =  copy.deepcopy(board)
                ggg=int(g[kk])
                blanks = random.sample(range(hs*hs), int(float(hs*hs*ggg)/100))
                for i in blanks:
                    row = i // hs
                    col = i % hs
                    board[row][col] = 0

                        
                    # if random.randint(0, hs) < level:
                    #     board1[row][col] = 0
                return board

            v = create_board() 
            # 81空34、46

                    
            # 提取每个元素
            

            for a1  in v:         # 第一次读取，[a,b][c,d][e,f]的内容-列表
                for a2 in a1:    # 第二次读取，[a,b,c,d,e,f]的内容-元素
                    if a2==0:                # 如果某个元素==0，就替换成空
                        P.append('')
                    else:      # 如果某个元素非0，就写入本身的数字
                        P.append(a2)
            print(P)
            print(len(P))
            Q=P

        doc = Document(path+r'\动物数独（6宫格横板）.docx')     

        print('------3、写入第几关，并将数字改成图片链接------')      
        # 获取第一个表格,写难度用的
        table = doc.tables[0]
        for b1 in range(0,1):
            # 在'00'单元格中插入文本
            cell_00 = table.cell(0, b1)
            cell_00_paragraph = cell_00.paragraphs[0]
            cell_00_paragraph.text =f"第 {kk+1} 关"
            cell_00_paragraph.style.font.bold = True
            cell_00_paragraph.style.font.size = Pt(24)
            cell_00_paragraph.style.font.name = "黑体"
            cell_00_paragraph.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER

    #    
        table = doc.tables[1]          # 表0，表2 写标题用的
        # 标题写入3、5单元格  
        for t in range(0,len(bg)):             # 0-5是最下面一行，用来写卡片数字
            pp=int(bg[t][0:2])     # 
            qq=int(bg[t][2:4])
            k=str(Q[t])              # 提取list图案列表里面每个图形  t=索引数字
            print(pp,qq,k)

            # 图案符号的字体、大小参数
            run=table.cell(pp,qq).paragraphs[0].add_run(k)    # 在单元格0,0(第1行第1列)输入第0个图图案
            run.font.name = '黑体'#输入时默认华文彩云字体
            # run.font.size = Pt(46)  #输入字体大小默认30号 换行（一页一份大卡片
            run.font.size = Pt(size) #是否加粗
            # run.font.color.rgb = RGBColor(150,150,150) #数字小，颜色深0-255
            run.font.color.rgb = RGBColor(0,0,0) #数字小，颜色深0-255
            run.bold=True
            # paragraph.paragraph_format.line_spacing = Pt(180) #数字段间距
        
            r = run._element
            r.rPr.rFonts.set(qn('w:eastAsia'), '黑体')#将输入语句中的中文部分字体变为华文行楷
            table.cell(pp,qq).paragraphs[0].alignment = WD_PARAGRAPH_ALIGNMENT.CENTER#居中  

            
        doc.save(imagePath+r'\{}.docx'.format('%02d'%(z+1)))#保存为XX学号的电话号码word   
        time.sleep(1)

        print('------4、每张word转为pdf----')      
        from docx import Document
        from docx.shared import Cm

        # 读取四张卡通动物的文件名
        animal_path = path+r'\02动物图片'  # 替换为实际的文件夹路径
        # 获取文件夹中所有文件的完整路径
        file_paths = [os.path.join(animal_path, file_name) for file_name in os.listdir(animal_path)]
        print(file_paths)

        # 把数字1替换成01图片
        # 打开Word文档
        doc = Document(imagePath+r'\{}.docx'.format('%02d'%(z+1)))

        # 获取所有表格
        tables = doc.tables

        # 遍历每个表格
        for table in tables:
            # 遍历表格的行
            for i, row in enumerate(table.rows):
                # 遍历行的单元格
                for j, cell in enumerate(row.cells):
                    # 读取单元格的文本值
                    cell_text = cell.text

                    for x in range(0,hs):
                    # 判断单元格的值是否为1
                        if cell_text == f'{x+1}':
                            # 删除原来的文本
                            cell.text = ''
                            # 插入图片
                            run = cell.paragraphs[0].add_run()
                            run.add_picture(file_paths[x], width=Cm(3), height=Cm(3))
                                # 设置图片对齐方式为居中
                            run.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
                            # 设置单元格的水平和垂直对齐方式为居中
                            cell.vertical_alignment = WD_ALIGN_PARAGRAPH.CENTER
                            cell.paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER
                        

        # 保存修改后的文档
        doc.save(imagePath+r'\{}.docx'.format('%02d'%(z+1)))
        time.sleep(2)

        # # 关闭Word文档
        # doc.close()
        time.sleep(2)
        from docx2pdf import convert
        # docx 文件另存为PDF文件
        inputFile = imagePath+"\{}.docx".format('%02d'%(z+1))# 要转换的文件：已存在
        outputFile = imagePath+"\{}.pdf".format('%02d'%(z+1))  # 要生成的文件：不存在
        # 先创建 不存在的 文件
        f1 = open(outputFile, 'w')
        f1.close()
        # 再转换往PDF中写入内容
        convert(inputFile, outputFile)
            
    print('----------第5步：把都有PDF合并为一个打印用PDF------------')
            
    # 多个PDF合并（CSDN博主「红色小小螃蟹」，https://blog.csdn.net/yangcunbiao/article/details/125248205）
    import os
    from PyPDF2 import PdfMerger
    target_path =  imagePath
    pdf_lst = [f for f in os.listdir(target_path) if f.endswith('.pdf')]
    pdf_lst = [os.path.join(target_path, filename) for filename in pdf_lst]
    pdf_lst.sort()
    file_merger = PdfMerger()
    for pdf in pdf_lst:
        print(pdf)
        file_merger.append(pdf)

    # vv=w[kk]
    file_merger.write(imagePath2+fr"\（打印合集） 动物拼图{hs}宫格 难度{kk+1:02d} 空{int(w[kk]):03d}格({db}乘{cb}等于{num}份{db*cb}张）.pdf")

    file_merger.close()
    # doc.Close()
    time.sleep(1)

    # # print('----------第5步：删除临时文件夹------------')    
    import shutil
    shutil.rmtree(imagePath) #递归删除文件夹，即：删除非空文件夹

    time.sleep(3)    # 防止转换时报错，预留生成时间


print('----------第6步：把都有PDF关卡变png------------')

#coding=utf-8
from win32com.client import Dispatch
import os
import re
import fitz
import shutil
wdFormatPDF = 17 #转换的类型
zoom_x=2 #尺寸大小，越大图片越清晰 5超大，这里改成2
zoom_y=2 #尺寸大小，越大图片越清晰，长宽保持一致
rotation_angle=0#旋转的角度，0为不旋转


# 新建装图片的零时文件夹
old_path =imagePath2  # 要复制的文件所在目录
os.makedirs(old_path,exist_ok=True)

new_path =old_path   #新路径


for root, dirs, files in os.walk(old_path):
    for file in files:
        if re.search('\.pdf$', file):
            filename = os.path.abspath(root + "\\" + file)
            print(filename)
            # 打开PDF文件
            pdf = fitz.open(filename)
            # 逐页读取PDF
            for pg in range(0, pdf.pageCount):
                page = pdf[pg]
                # 设置缩放和旋转系数
                trans = fitz.Matrix(zoom_x, zoom_y).preRotate(rotation_angle)
                pm = page.getPixmap(matrix=trans, alpha=True)
                # 开始写图像
                pm.writePNG(filename.replace('.pdf', '') + str(pg+1) + ".png")
            pdf.close()

# 删除生成文件PDF  
for parent, dirnames, filenames in os.walk(new_path):
    for fn in filenames:
        if fn.lower().endswith('.pdf'):
            os.remove(os.path.join(parent, fn))



            
print('----------第7步：把关卡png六张六张写入docx，转pdf------------')

    
# -*- coding:utf-8 -*-

'''
动物数独六宫格 关卡图片变成图片后写入A4一页6张
作者：AI对话大师，阿夏
时间：2024年4月22日
# '''

# print('----1、读取行列-------')
from docx import Document
from docx.shared import Cm
import os


# # 新建一个”装N份word和PDF“的临时文件夹
imagePath=path+r'\\零时Word'
if not os.path.exists(imagePath):  # 判断存放图片的文件夹是否存在
    os.makedirs(imagePath)  # 若图片文件夹不存在就创建
# 打开.docx文件
doc = Document(path +r'\动物数独（6宫格横板）关卡.docx')

# 获取文档中的所有表格
tables = doc.tables

# 选择你需要读取的表格（在这种情况下是第1张表格）
target_table = tables[0]

# 获取所选表格的行数和列数
num_rows = len(target_table.rows)
num_columns = len(target_table.columns)

print("行数:", num_rows)
# 3
print("列数:", num_columns)
# # 2


import os

# 指定文件夹路径
folder_path =old_path

# 读取文件夹中所有文件的名称并加上路径
file_paths = [os.path.join(root, file) for root, dirs, files in os.walk(folder_path) for file in files]
print(file_paths)
print(len(file_paths))

pic_list_six = [file_paths[i:i+hsall] for i in range(0, len(file_paths), hsall)]



# print('----3、插入图片-------')
for f in range(len(pic_list_six)):
# # 打开.docx文件
    doc = Document(path +r'\动物数独（6宫格横板）关卡.docx')

    # 获取文档中的所有表格
    tables = doc.tables

    # 获取第一个表格
    table = tables[0]    

    # 遍历表格的所有行和单元格   
    i = 0
    for row in table.rows:
        for cell in row.cells:
            # 在单元格中插入图片
            cell_paragraph = cell.paragraphs[0]
            run = cell_paragraph.add_run()
            run.add_picture(pic_list_six[f][i], width=Cm(8.82), height=Cm(9.6))
            # Cm(9.84), height=Cm(9.84))
            cell_paragraph.alignment = 1  # 设置单元格中的文本居中
            i += 1
               
            

    # 保存修改后的.docx文件
    doc.save(imagePath + fr'\动物数独卡片{f:02d}页.docx')
    from docx2pdf import convert
    # docx 文件另存为PDF文件
    inputFile =imagePath + fr'\动物数独卡片{f:02d}页.docx'# 要转换的文件：已存在
    outputFile = imagePath + fr'\动物数独卡片{f:02d}页.pdf' # 要生成的文件：不存在
    # 先创建 不存在的 文件
    f1 = open(outputFile,'w')
    f1.close()
    # 再转换往PDF中写入内容
    convert(inputFile, outputFile)

from docx2pdf import convert


    
import os
from PyPDF2 import PdfMerger

pdf_lst = [f for f in os.listdir(imagePath) if f.endswith('.pdf')]
pdf_lst = [os.path.join(imagePath, filename) for filename in pdf_lst]
pdf_lst.sort()
file_merger = PdfMerger()
for pdf in pdf_lst:
    print(pdf)
    file_merger.append(pdf)
# file_merger.write("C:/Users/jg2yXRZ/OneDrive/桌面/描字帖/（打印合集）大班A整页描字帖2乘5加表格-4名字-（{}人）.pdf".format(num))
file_merger.write(imagePath3+r"\（打印合集)动物数独6宫格关卡.pdf")
file_merger.close()
# doc.Close()

# # print('----------第5步：删除临时文件夹------------')    
import shutil
shutil.rmtree(imagePath) #递归删除文件夹，即：删除非空文件夹
import shutil
shutil.rmtree(imagePath2) #递归删除文件夹，即：删除非空文件夹
      



print('----------第8步：把关卡pdf和图卡pdf合并在一起------------')


# 最后把PDF合并
import os
from PyPDF2 import PdfMerger, PdfFileReader

# 创建一个PdfMerger对象
merger = PdfMerger()

# 遍历文件夹中的所有PDF文件

folder_path = path
for filename in os.listdir(imagePath3):
    if filename.endswith('.pdf'):
        # 打开PDF文件z
        pdf_path = os.path.join(imagePath3, filename)
        pdf_file = open(pdf_path, 'rb')
        pdf_reader = PdfFileReader(pdf_file)
        
        # 将PDF文件添加到合并器中
        merger.append(pdf_reader)
        
        # 关闭当前打开的PDF文件
        pdf_file.close()

# 保存合并后的PDF文件
output_path = path+fr"\动物数独{hs}宫格（空格1-{len(w)}（{len(w)}关卡图和{hs*hs}大图卡）.pdf"
merger.write(output_path)
merger.close()

print("PDF文件合并完成！")

import shutil
shutil.rmtree(imagePath3) #递归删除文件夹，即：删除非空文件夹

第零关：制作大图卡

第一关：制作大图卡

第三关：PDF转png，删除PDF，所有PNG插入关卡模板（一页6张）合并生成PDF

第四关：合并关卡图和动物图卡

最后效果：

6张动物大图片（36个9.84CM动物头像）

 6张关卡图片（9,7CM图片，共36关）

如果有同行，需要订制动物数独的图案（动物主题、植物主题、人物主题），可以私信联系

阿夏reasonsummer
关注
  • 34
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
四宫格-儿童数独-练习60题 可打印
01-21
Sheet11131223432431432134132241112434341424211324311334312431231214121443212332143131143412131321223
【教学类-43-12】A4最终版 20231231 数独10.0 N宫格X*Y=Z套(n=3-9)，套用不同的A4横版模板
12-31
制作M宫格数独时用到的各类word模板
【教学类-52-01】20240411动物数独（4宫格）宫格图
reasonsummer的博客
04-12 1001
【教学类-52-01】20240411动物数独（4宫格）宫格图
【教学类-52-04】20240412动物数独（4宫格）空1-空15
reasonsummer的博客
04-13 459
【教学类-52-04】20240412动物数独（4宫格）空1-空15
【教学类-52-05】20240417动物数独（4宫格）黏贴卡片需要至少几张？难度1-9 打印版
reasonsummer的博客
04-16 792
【教学类-52-05】20240417动物数独（4宫格）黏贴卡片需要至少几张？难度1-9 打印版
【教学类-52-03】20240412动物数独（4宫格）难度1-9 打印版
reasonsummer的博客
04-12 1129
【教学类-52-03】20240412动物数独（4宫格）难度1-9 打印版
四宫格-简单入门级数独练习60题-(支持打印)
01-20
Sheet1四宫格-简单入门级数独练习60题-(支持打印)11312234324314321341322411124343414242113243113343124312312141214432123
数独四宫格3-5岁儿童练习题-简单版.doc
10-10
数独四宫格3-5岁儿童练习题-简单版.doc
python复习（三）
qq_43710593的博客
04-29 306
类是一种面向。
SpringBoot中实现发送邮件
最新发布
m0_64289188的博客
04-30 491
当你添加了spring-boot-starter-mail依赖后，Spring Boot会自动配置JavaMailSender实例，并根据application.yml文件中的属性来配置这个实例。你可以直接在需要发送邮件的地方通过@Autowired注解将JavaMailSender实例注入到你的类中，然后使用它来发送邮件。：首先，需要在你的pom.xml文件中添加Spring Boot的邮件发送器依赖。，简化了在Spring Boot应用程序中发送电子邮件的设置过程。Spring Boot的。
python学习笔记----循环语句（四）
取个名字太难了a的博客
04-28 959
随机数种子在生成随机数的过程中起到一个非常重要的作用。它是用于初始化随机数生成算法（伪随机数生成器）的初始值。随机数种子的作用可重复性：当你使用特定的种子值初始化随机数生成器时，即使在不同的运行环境或不同时间，生成的随机数序列都将是相同的。这对于调试和测试非常重要，因为它允许程序的行为在使用随机数时保持一致。控制随机性：种子提供了一种方法来控制随机数生成过程。通过改变种子，你可以获得不同的随机数序列，这对于模拟和其他需要随机输入的应用非常有用。
Day25-Java基础之常用类1
m0_46053885的博客
04-27 1099
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
链表刷题集
yajunjiao的专栏
04-30 471
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
【python】python基础1
七月尘上
04-29 364
注释：单行注释：#多行注释：“”“”“”批量注释：ctl+?,取消注释继续执行一次就行标识符命名规范：1、变量名、类名、函数名只能由数字、字母、下划线组成2、不能以数字开头3、严格区分大小写4、不能以关键字命名定义变量的方式：1、var1 = 值12、var1,var2=值1，值23、var1,var2=值1交换两个变量的值：输出命令解析：sep:输出内容以什么进行分割end:输出以什么结尾file:输出内容以文件形式输出到指定文件。
ROS学习教程--第一篇（初试ROS）
隔壁老姚的博客
04-29 505
上述命令，会在工作空间下生成一个功能包，该功能包依赖于 roscpp、rospy 与 std_msgs，其中roscpp是使用C++实现的库，而rospy则是使用python实现的库，std_msgs是标准消息库，创建ROS功能包时，一般都会依赖这三个库实现。该文件定义有关软件包的属性，例如软件包名称，版本号，作者，维护者以及对其他catkin软件包的依赖性。在自定义包basic_correspondence的src目录下创建person_talker.py，编辑以下内容。
python基础知识
2301_77724654的博客
04-28 409
基本输入input()，若要输出整数或小数，可用int()，float()函数进行数据类型转换。缩进：Python使用缩进表示代码块，连续的具有相同缩进的多条语句为一个代码块，语句末尾为代码块的开头，同一个代码块要有相同的缩进。1 在Python3中，print()函数取代了Python2中的print语句。2 Python中程序文件运行方式为程序文件运行，交互式运行两种。赋值语句，简单赋值与序列赋值等，序列赋值可一次为多个变量赋值。注释：单行注释用#，多行注释用'''或'''''''
superset部署与实践
m0_60125201的博客
04-29 804
本博客简要介绍了superset这个BI工具，使用两种方法来部署superset，并简单介绍了superset的使用。
AttributeError: module ‘numpy‘ has no attribute ‘float‘.的解决方法
chen_znn的博客
04-30 404
本文记录了AttributeError: module 'numpy' has no attribute 'float'.的解决方法
matlab之6宫格数独
09-13
对于6宫格数独的解法，你可以使用Matlab来实现。下面是一个使用回溯算法求解6宫格数独的示例代码： ```matlab function solveSudoku(grid) if solveHelper(grid) % 调用辅助函数进行求解 disp('解法找到：'); ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

阿夏reasonsummer

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值