发表于 | 分类于

奇技淫巧不可取，切记切记

之前我们介绍过Python有一个模块可以用来检查代码风格，并且u1s1，检查得还挺严的，搞得阿酱还挺怕怕的

就像读书时候有一个严厉的老大哥、啊不对，老师，一直始终盯着你，一旦犯错就会对你提出严厉的批评，羞得你无地自容。

阅读全文 »

发表于 | 分类于

一年一度的双十一就快到了，各种砍价、盖楼、挖现金的口令将在未来一个月内充斥朋友圈、微信群中。玩过多次双十一活动的小编表示一顿操作猛如虎，一看结果2毛5。浪费时间不说而且未必得到真正的优惠，双十一电商的“明降暗升”已经是默认的潜规则了。打破这种规则很简单，可以用 Python 写一个定时监控商品价格的小工具。

阅读全文 »

发表于 | 分类于

最近，随处可见的关键词都是“阿里P7”、“字节跳动”、“挑战年薪50W”等等。看过这些之后，你是否会产生焦虑和迷茫？

虽然我没都知道这些标题党就是用这些关键词来刺激大家敏感的神经，从而参加他们的培训或者讲座，赚取焦虑的学费。虽然大家大部分也不会去报名，但是可能大部分人的心里种下了一颗不安的种子，随着这些关键词不断地出现在眼前，这颗种子会发芽、生长，慢慢地会让我们产生焦虑和迷茫。

其实大可不必这样，每个人都有自己的生存和生活方式，没必要一味地追求高薪，我们还要有诗和远方。

下面我来抛砖引玉，说说我作为程序员，对我们这个群体的一些想法。

阅读全文 »

发表于 | 分类于

扫雷是一款益智类小游戏，最早于 1992 年由微软在 Windows 上发行，游戏适合于全年龄段，规则简单，即在最短的时间内找出所有非雷格子且在中间过程中不能踩到雷， 踩到雷则失败，需重新开始。

阅读全文 »

发表于 | 分类于

从石器时代开始，原始人来已经开始学会制造并使用工具，以满足自己的生活所需，这也是人类和动物最本质的区别，人类懂得制造并使用工具而动物不会。

21 世纪的现代社会更是如此，企业与企业之间是人才的竞争，而人的竞争力则严重依赖其会使用工具的多少以及熟练程度，毕竟古人有云：「君子生非异也，善假于物也」。

阅读全文 »

发表于 | 分类于

标题图片 相比于子弹时间和火爆场景，我更喜欢《黑客帝国》故事背景的假设 —— 人们熟悉的世界是虚构的，是机器给人大脑输入的幻象，而幻象是不完美的，存在一些不符合自然规律的地方，这些地方或多或少的展示了幻象世界的破绽和真实世界的样子，如果你看过《黑客帝国》动画版《超越极限》和《世界纪录》，将会有更深刻的感受

我们熟悉的、赖以生存的 Python 世界，其实也是个虚拟的，这个虚拟世界展示给我们无比绚烂的场景和功能的同时，也存在一些超乎常理和认知的地方，今天就带你一起探寻一些那些超自然点，以及它背后的真实世界

阅读全文 »

发表于 | 分类于

在日常生活中总是有给图像分类的场景，比如垃圾分类、不同场景的图像分类等；今天的文章主要是基于图像识别场景进行模型构建。图像识别是通过 Python深度学习来进行模型训练，再使用模型对上传的电子表单进行自动审核与比对后反馈相应的结果。主要是利用 Python Torchvision 来构造模型，Torchvision 服务于Pytorch 深度学习框架，主要是用来生成图片、视频数据集以及训练模型。

模型构建

构建模型为了直观，需要使用 Jupyter notebook 进行模型的构建，Jupyter notebook 的安装及使用详见公众号历史文章 一文吃透 Jupyter Notebook,进入 JupyterNotebook 页面后即可进行编辑。详细页面如下：

导入所需包

图像识别需要用到深度学习相关模块，所以需要导入相应的包，具体导入的包如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
%reload_ext autoreload
%autoreload 2

import torch
from torch.utils.data import DataLoader
from torchvision.datasets import ImageFolder
from torchvision import transforms as tfs
from torchvision import models
from torch import nn

import matplotlib.pyplot as plt
%matplotlib inline

import os
os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"

是否使用 GPU

模型的训练主要方式是基于 GPU 或者 CPU 训练，在没有 GPU 的条件下就在 CPU 下进行训练，模型的训练需要花费一定的时间，训练时长根据训练集的数据和硬件性能而定，训练结果精确性根据数据的多少和准确性而且，深度学习需要大量的素材才能判断出精确的结果，所以需要申明使用 CPU 进行训练：

1
2
# 是否使用GPU
use_gpu = False

数据增强

将拿到的数据进行训练集的数据预处理并设置训练分层数，再将拿到的图片进行水平翻转后对图片进行剪裁， 剪裁后将图片进行随机翻转，增强随机对比度以及图片颜色变化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 数据增强
train_transform = tfs.Compose([
    # 训练集的数据预处理
    tfs.Resize([224, 224]),
    tfs.RandomHorizontalFlip(),
    tfs.RandomCrop(128),
    tfs.ToTensor(),
    tfs.Normalize([0.5,0.5,0.5], [0.5,0.5,0.5])
])

test_transform = tfs.Compose([
    tfs.Resize([224,224]),
#     tfs.RandomCrop(128),
    tfs.ToTensor(),
    tfs.Normalize([0.5,0.5,0.5], [0.5,0.5,0.5])
])

# 每一个batch的数据集数目
batch_size = 10

数据集和验证集准备

模型训练需要准备数据集和验证集，只有足够的照片才能得到更精准的答案。训练集和验证集部分代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 构建训练集和验证集
# 
train_set = ImageFolder('./dataset1/train', train_transform)
train_data = DataLoader(train_set, batch_size, shuffle=True, num_workers=0)

valid_set = ImageFolder('./dataset1/valid', test_transform)
valid_data = DataLoader(valid_set, 2*batch_size, shuffle=False, num_workers=0)

train_set.class_to_idx

len(valid_data)

# 数据集准备
try:
    if iter(train_data).next()[0].shape[0] == batch_size and \
    iter(valid_data).next()[0].shape[0] == 2*batch_size:
        print('Dataset is ready!')
    else:
        print('Not success, maybe the batch size is wrong')
except:
    print('not success, image transform is wrong!')

模型构建并准备模型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 构建模型
def get_model():
    model = models.resnet50(pretrained=True)
    model.fc = nn.Linear(2048, 3)
    return model

try:
    model = get_model()
    with torch.no_grad():
        scorce = model(iter(train_data).next()[0])
        print(scorce.shape[0], scorce.shape[1])
    if scorce.shape[0] == batch_size and scorce.shape[1] == 3:
        print('Model is ready!')
    else:
        print('Model is failed!')
except:
    print('model is wrong')

if use_gpu:
    model = model.cuda()

构建模型优化器

1
2
3
4
5
6
7
# 构建loss函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr = 1e-4)

# 训练的epoches数目
max_epoch = 20

模型训练和训练结果可视化

数据集和训练集准备好后进行模型训练和训练结果可视化，部分代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
def train(model, train_data, valid_data, max_epoch, criterion, optimizer):
    freq_print = int(len(train_data) / 3)
    
    metric_log = dict()
    metric_log['train_loss'] = list()
    metric_log['train_acc'] = list()
    if valid_data is not None:
        metric_log['valid_loss'] = list()
        metric_log['valid_acc'] = list()
    
    for e in range(max_epoch):
        model.train()
        running_loss = 0
        running_acc = 0

        for i, data in enumerate(train_data, 1):
            img, label = data
            if use_gpu:
                img = img.cuda()
                label = label.cuda()

            # forward前向传播
            out = model(img)

            # 计算误差
            loss = criterion(out, label.long())

            # 反向传播，更新参数
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

            # 计算准确率
            _, pred = out.max(1)
            num_correct = (pred == label.long()).sum().item()
            acc = num_correct/img.shape[0]

            running_loss += loss.item()
            running_acc +=acc

            if i % freq_print == 0:
                print('[{}]/[{}], train loss: {:.3f}, train acc: {:.3f}' \
                .format(i, len(train_data), running_loss / i, running_acc / i))
        
        metric_log['train_loss'].append(running_loss / len(train_data))
        metric_log['train_acc'].append(running_acc / len(train_data))

        if valid_data is not None:
            model.eval()
            running_loss = 0
            running_acc = 0
            for data in valid_data:
                img, label = data
                if use_gpu:
                    img = img.cuda()
                    label = label.cuda()
                
                # forward前向传播
                out = model(img)

                # 计算误差
                loss = criterion(out, label.long())

                # 计算准确度
                _, pred = out.max(1)
                num_correct = (pred==label.long()).sum().item()
                acc = num_correct/img.shape[0]


                running_loss += loss.item()
                running_acc += acc

            metric_log['valid_loss'].append(running_loss/len(valid_data))
            metric_log['valid_acc'].append(running_acc/len(valid_data))
            print_str = 'epoch: {}, train loss: {:.3f}, train acc: {:.3f}, \
            valid loss: {:.3f}, valid accuracy: {:.3f}'.format(
                        e+1, metric_log['train_loss'][-1], metric_log['train_acc'][-1],
                        metric_log['valid_loss'][-1], metric_log['valid_acc'][-1])
        else:
            print_str = 'epoch: {}, train loss: {:.3f}, train acc: {:.3f}'.format(
                e+1,
                metric_log['train_loss'][-1],
                metric_log['train_acc'][-1])
        print(print_str)

        
    # 可视化
    nrows = 1
    ncols = 2
    figsize= (10, 5)
    _, figs = plt.subplots(nrows, ncols, figsize=figsize)
    if valid_data is not None:
        figs[0].plot(metric_log['train_loss'], label='train loss')
        figs[0].plot(metric_log['valid_loss'], label='valid loss')
        figs[0].axes.set_xlabel('loss')
        figs[0].legend(loc='best')
        figs[1].plot(metric_log['train_acc'], label='train acc')
        figs[1].plot(metric_log['valid_acc'], label='valid acc')
        figs[1].axes.set_xlabel('acc')
        figs[1].legend(loc='best')
    else:
        figs[0].plot(metric_log['train_loss'], label='train loss')
        figs[0].axes.set_xlabel('loss')
        figs[0].legend(loc='best')
        figs[1].plot(metric_log['train_acc'], label='train acc')
        figs[1].axes.set_xlabel('acc')
        figs[1].legend(loc='best')

调参进行模型训练

1
2
# 用作调参
train(model, train_data, valid_data, max_epoch, criterion, optimizer)

保存模型

1
2
# 保存模型
torch.save(model.state_dict(), './model/save_model2.pth')

总结

今天的文章主要是讲图像识别模型如何构建。希望对大家有所帮助。

你安利到了吗？

示例代码 Python 教你如何给图像分类

阅读全文 »

发表于 | 分类于

2020 注定是不平凡的一年，一开年就被新冠疫情来了当头一棒，一瞬间大家都不约而同的采取家里蹲策略，在政府的得力领导下，全部人民上下一条心，到了四五月份终于将疫情稳定控制住了，时隔半年，国内疫情早已趋于稳定，人们的生活也基本恢复正常。

恰逢国庆中秋两个节日重合，在家憋这么久的人们怎么能不出去看看祖国的大好河山。据新华网消息，整个国庆长假外出游玩人次达 6.37 亿人次，那么这么多人都到哪儿去玩了呢，今天我们就用 Python 做一个全国热门景区热点图。

阅读全文 »

发表于 | 分类于

小编之前写了一篇关于 Office 文件转 PDF 的实战文章，详见Python 小技之 Office 文件转 PDF 但是在平时的工作中，咱们需要通过接口的形式来调用具体的转换逻辑，同时开可以将文件转换写成服务的形式，将服务开启后传入参数或者地址即可直接调用逻辑转换，今天的文章主要讲解如何将文件转换写成服务；

一起拭目以待吧！！！

文件服务器

Office 文件转 PDF 涉及到文件的传输，所以考虑用文件服务器来进行文件的传递，客户端如果有文件服务器的话， 同样在服务端也需要写一个文件服务器来返回转换完成的文件，以供客户端使用，文件服务器实现思路如下：

逻辑结构

文件结构结构逻辑图如下：

代码结构

前端文件上传下载页面

1
2
3
4
5
6
7
8
9
10
<body>
    <form action="download" method="GET",enctype="multipart/form-data">
        要下载的文件: <input type="text" value="请上传文件" name="filename" />
        <input type="submit" value="download">
    </form>

    <form action="/file_server/cgi-bin/upload.py" method="POST" enctype="multipart/form-data">
        要上传的文件: <input type="file" name="filename" />
        <input type="submit" value="upload">
    </form>

上传文件

上传文件 upload.py 部分代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import cgi, os

form = cgi.FieldStorage()

item = form["filename"]

if item.filename:
    fn = os.path.basename(item.filename)
    open("/home/sxhlinux/data/" + fn, "wb").write(item.file.read())
    msg = "File" + fn + ' upload successfully !'
else:
    msg = 'no file is uploaded '

print("""\
Content-type: text/html\n
<html>
<head>
<meta charset="utf-8">
<title>Hello world</title>
</head>
<body>
<h2>名称: %s</h2>
</body>
<html>
""" % (msg,))

下载文件

下载文件 download.py 部分代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
form = cgi.FieldStorage()

filename = form.getvalue('filename')

dir_path = "F:/WorkSpace/FilesToPDF/file_server/tmp"

target_path = dir_path + str(filename)

if os.path.exists(target_path) == True:
    print("Content-Type: application/octet-stream")
    print('Content-Disposition: attachment; filename = "%s"' % filename)

    print(target_path)

    sys.stdout.flush()
    fo = open(target_path, "rb")
    sys.stdout.buffer.write(fo.read())
    fo.close()
else:
    print("""\
            Content-type: text/html\n
            <html>
            <head>
            <meta charset="utf-8">
            <title>File server</title>
            </head>
            <body>
            <h1> %s doesn't exist in the server:
            files in the server list below: </h1>""" % filename)

    for line in os.popen(filename):
        name = line.strip().split(' ', 8)
        type(name)
        if len(name) == 9:
            print("""
            <form action="/cgi-bin/download.py" method="get">%s
            <input type="submit" name="filename" value="%s">
            </form>""" % (line, name[8]))

文件服务

文件服务入口 server.py 部分代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

if __name__ == '__main__':
    try:
        handler = CGIHTTPRequestHandler
        handler.cgi_directories = ['/cgi-bin', '/htbin']
        #port = int(sys.argv[1])
        port = 8001
        print('port is %d' % port)
        server = HTTPServer(('', port), handler)
        print('Welcome to my website !')
        server.serve_forever()

    except KeyboardInterrupt:
        print('^C received, shutting down server')
        server.socket.close()

以上服务启动后即可使用。

转换逻辑接口

转换接口使用了 Python Flask框架，在文件转换逻辑里面需要引入具体的转换逻辑，接口逻辑实现代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
from flask import Flask, render_template,request
import requests
import config
from requests import get
import files2pdf  # 引入转换逻辑
import os, shutil
from flask import Flask, render_template, url_for, send_from_directory,json,make_response,jsonify

app = Flask(__name__, static_folder='/static')
app.config.from_object(config)
app.config["SECRET_KEY"] = "123456"

@app.route('/')
def index():
    return "Welcome to You,Please visit the url:http://IP:5000/upload_file?filePath=xxx.pptx"

#pathname = ''
@app.route('/upload_file', methods=['GET', 'POST'])
def upload_file():
        if request.method == 'POST' or request.method == 'GET':
            file_url = request.args.get('filePath', '')
            req = get(file_url)
            if req.status_code == 404:
                print("no file")

                return
            # 取正确的转换文件名称
            filename = file_url.split('/')[-1]
            name = filename.split('?')[1]
            ppt_name = name.split('=')[-1]
            print(ppt_name)

            with open(ppt_name, "wb") as file:
                # get request
                # response = get(url)
                # write to file
                file.write(req.content)

            # 判断要转换的文件是否存在
            if os.path.exists(ppt_name) and not os.path.exists(file_path + '/' + ppt_name):
                shutil.move(ppt_name, file_path)
            elif os.path.exists(ppt_name) and os.path.exists(file_path + '/' + ppt_name):
                print('file alreadly exists')
                os.remove(ppt_name)
                print("already deleted exists file")

            pdfConverter = files2pdf.PDFConverter(file_path + '/' + ppt_name)  # 调用文件转换逻辑
            # print("transform complete:"+pdfConverter)
            pdfConverter.run_conver()

            # file transform finshed --> Get file's name
            re_name = ppt_name.replace('.pptx', '.pdf')
            print('New name is:' + re_name)
            # /static/%E6%B0%B4%E9%92%A2%E9%9B%86%E5%9B%A2%E6%99%BA%E6%85%A7%E5%85%9A%E5%BB%BA%E5%9F%B9%E8%AE%AD%E8%B5%84%E6%96%990420%282%29.pdf
            re_url = 'IP:8001'  # 文件服务地址
            # urlfor = url_for('static', filename=re_name)
            return re_url + url_for('static', filename=re_name)
            #return  render_template('result_link.html')

if __name__ == '__main__':

    app.run(host='0.0.0.0', port=5000)

调用

先启动 server.py 后再启动 flaskdemo.py 传入参数即可调用逻辑。也可以用 postman 调用，调用实例如下：

调用实例

总结

今天的文章主要是继上一篇 Python 实战之小工具的运用的延申，希望对大家有所帮助，如有问题咱们讨论区见！

So 今天的小 Tip 你安利到了吗？

示例代码 Office 文件转 PDF 之服务实战

阅读全文 »

发表于 | 分类于

工具需用好，阅读源码没烦恼

每当我们接手一个新项目时，面对庞杂的模块、繁复的代码，想必心情是非常绝望的，“这都特么啥呀？”

如果你也有这样的烦恼，那你就应该看这篇文章。

阅读全文 »

发表于 | 分类于

Python少有人走过的坑

毫无疑问，print函数是我们日常最常用的函数，无论是格式化输出还是打印中间变量进行调试，几乎没有print接不了的活儿。

但是上一次阿酱就差点被print给坑了。

阅读全文 »

发表于 | 分类于

在平时的工作中，难免需要一些 小Tip 来解决工作中遇到的问题，今天的文章给大家安利一个方便快捷的小技巧，将 Office（doc/docx/ppt/pptx/xls/xlsx）文件批量或者单一文件转换为 PDF 文件。 不过在做具体操作之前需要在 PC 安装好 Office，再利用 Python 的 win32com 包来实现 Office 文件的转换操作。

安装 win32com

在实战之前，需要安装 Python 的 win32com,详细安装步骤如下：

使用 pip 命令安装

1
2
3

pip install pywin32

如果我们遇到安装错误，可以通过python -m pip install –upgrade pip更新云端的方式再进行安装即可：

1
2
3

python -m pip install --upgrade pip

下载离线安装包安装

如果 pip 命令未安装成功的话还可以下载离线包安装，方法步骤如下： 首先在官网选择对应的 Python 版本下载离线包：https://sourceforge.net/projects/pywin32/files/pywin32/Build%20221/ 下载好后傻瓜式安装好即可。

文件转换逻辑

详细代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
class PDFConverter:
    def __init__(self, pathname, export='.'):
        self._handle_postfix = ['doc', 'docx', 'ppt', 'pptx', 'xls', 'xlsx'] # 支持转换的文件类型
        self._filename_list = list()  #列出文件
        self._export_folder = os.path.join(os.path.abspath('.'), 'file_server/pdfconver')
        if not os.path.exists(self._export_folder):
            os.mkdir(self._export_folder)
        self._enumerate_filename(pathname)

    def _enumerate_filename(self, pathname):
        '''
        读取所有文件名
        '''
        full_pathname = os.path.abspath(pathname)
        if os.path.isfile(full_pathname):
            if self._is_legal_postfix(full_pathname):
                self._filename_list.append(full_pathname)
            else:
                raise TypeError('文件 {} 后缀名不合法！仅支持如下文件类型：{}。'.format(pathname, '、'.join(self._handle_postfix)))
        elif os.path.isdir(full_pathname):
            for relpath, _, files in os.walk(full_pathname):
                for name in files:
                    filename = os.path.join(full_pathname, relpath, name)
                    if self._is_legal_postfix(filename):
                        self._filename_list.append(os.path.join(filename))
        else:
            raise TypeError('文件/文件夹 {} 不存在或不合法！'.format(pathname))

    def _is_legal_postfix(self, filename):
        return filename.split('.')[-1].lower() in self._handle_postfix and not os.path.basename(filename).startswith(
            '~')

    def run_conver(self):
        print('需要转换的文件数是：', len(self._filename_list))
        for filename in self._filename_list:
            postfix = filename.split('.')[-1].lower()
            funcCall = getattr(self, postfix)
            print('原文件：', filename)
            funcCall(filename)
        print('转换完成！')

doc/docx 转换为 PDF

doc/docx 转换为 PDF 部分代码如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

    def doc(self, filename):
        name = os.path.basename(filename).split('.')[0] + '.pdf'
        exportfile = os.path.join(self._export_folder, name)
        print('保存 PDF 文件：', exportfile)
        gencache.EnsureModule('{00020905-0000-0000-C000-000000000046}', 0, 8, 4)
        pythoncom.CoInitialize()
        w = Dispatch("Word.Application")
        pythoncom.CoInitialize()  # 加上防止 CoInitialize 未加载
        doc = w.Documents.Open(filename)
        doc.ExportAsFixedFormat(exportfile, constants.wdExportFormatPDF,
                                Item=constants.wdExportDocumentWithMarkup,
                                CreateBookmarks=constants.wdExportCreateHeadingBookmarks)
        w.Quit(constants.wdDoNotSaveChanges)
	def docx(self, filename):
        self.doc(filename)

ppt/pptx 转换为 PDF

ppt/pptx 转换为 PDF 部分代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

	def ppt(self, filename):
        name = os.path.basename(filename).split('.')[0] + '.pdf'
        exportfile = os.path.join(self._export_folder, name)
        gencache.EnsureModule('{00020905-0000-0000-C000-000000000046}', 0, 8, 4)
        pythoncom.CoInitialize()
        p = Dispatch("PowerPoint.Application")
        pythoncom.CoInitialize()
        ppt = p.Presentations.Open(filename, False, False, False)
        ppt.ExportAsFixedFormat(exportfile, 2, PrintRange=None)
        print('保存 PDF 文件：', exportfile)
        p.Quit()

    def pptx(self, filename):
        self.ppt(filename)

xls/xlsx 转换为 PDF

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
    def xls(self, filename):
        name = os.path.basename(filename).split('.')[0] + '.pdf'
        exportfile = os.path.join(self._export_folder, name)
        pythoncom.CoInitialize()
        xlApp = DispatchEx("Excel.Application")
        pythoncom.CoInitialize()
        xlApp.Visible = False
        xlApp.DisplayAlerts = 0
        books = xlApp.Workbooks.Open(filename, False)
        books.ExportAsFixedFormat(0, exportfile)
        books.Close(False)
        print('保存 PDF 文件：', exportfile)
        xlApp.Quit()

    def xlsx(self, filename):
        self.xls(filename)

执行逻辑转换

1
2
3
4
5
6
7
8
if __name__ == "__main__":
    # 支持文件夹批量导入
    #folder = 'tmp'
    #pathname = os.path.join(os.path.abspath('.'), folder)
    # 也支持单个文件的转换
    pathname = "G:/python_study/test.doc"
    pdfConverter = PDFConverter(pathname)
    pdfConverter.run_conver()

总结

今天的文章主要是 Python 实战之小工具的运用，希望对大家有所帮助，下一期将讲解如何通过接口的方式通过文件服务器来下载文件并转换，敬请期待。。。 So 今天的小 Tip 你安利到了吗？

示例代码 Python 小技之 Office 文件转 PDF

阅读全文 »

发表于 | 分类于

为什么越来越多的非程序员白领都开始学习 Python ？他们可能并不是想要学习 Python 去爬取一些网站从而获得酷酷的成就感，而是工作中遇到好多数据分析处理的问题，用 Python 就可以简单高效地解决。本文就通过一个实际的例子来给大家展示一下 Python 是如何应用于实际工作中高效解决复杂问题的。

阅读全文 »

发表于 | 分类于

前几天，给儿子买了个飞行棋，甚是喜欢，每天都要和我来两盘，昨天准备大战一场时，发现骰子弄丢了，没有骰子就没法玩了，正想要用橡皮做一个，突然想到了个更好的办法，经过一顿折腾，终于搞定了，结果……

阅读全文 »

发表于 | 分类于

提到老师，大家首先想到的可能就是在学校中教我们文化课的人，除此之外，在生活或工作中给予我们指导及帮助的人也可称之为老师，今天是教师节，本文我们就使用 Python 来为所有的老师送上节日的祝福。

阅读全文 »