python怎么下一行

用过手机QQ就知道，点击一个图片会弹出一个小功能，那就是提取图片中的文字。非常方便实用，那么很难实现吗？

利用Python提取图片中的文字信息，只需要一行代码就能搞定！

当然，这是吹牛皮的，但是真正的Python代码也就第4行，说是一行代码搞定也没错。

示例：

效果

尽管运行Python代码后也有几个错误的地方，但是大部分是识别正确的。你以为就这样结束了吗？那这么简单，我都不用出教程了。一行代码实现这个功能当然也是要有前戏的。

一，pytesseract和PIL的安装

pip安装

2，pycharm编辑器能够快速安装，这就看你是否用pycharm了。

pycharm的Settings设置页按照下面步骤操作

安装好了pytesseract，安装PIL在上面第三步里搜索PIL并点击安装就可以了。

安装好了所有库，运行下面Python代码

出现报错

可以看到提示：未安装识别引擎tesseract-ocr

二，安装识别引擎tesseract-ocr

1.网上下载安装包，然后直接点击安装即可

因为tesseract-ocr默认不支持中文识别，所以解压安装tesseract-ocr后还需做如下操作

2，安装完成tesseract-ocr后，我们还需配置好

打开后做如下操作

当然也能由pycharm快速打开pytesseract.py

第一步：

第二步：

第三步：

现在已经完成了所有配置，运行下面Python代码即可实现图片里的文字提取

本文到此就结束了，希望各位Python越学越好，早日达成梦想。

译者：caspar

译文：https://segmentfault/a/1190000000414339原文：https://medium/building-things-on-the-internet/40e9b2b36148

Python在程序并行化方面多少有些声名狼藉。撇开技术上的问题，例如线程的实现和 GIL，我觉得错误的教学指导才是主要问题。常见的经典 Python多线程、多进程教程多显得偏"重"。而且往往隔靴搔痒，没有深入探讨日常工作中最有用的内容。

传统的例子

简单搜索下"Python多线程教程"，不难发现几乎所有的教程都给出涉及类和队列的例子：

#Example.py

'''

Standard Producer/ConsumerThreading Pattern

'''

importtime

importthreading

importQueue

classConsumer(threading.Thread):

def__init__(selfqueue):

threading.Thread.__init__(self)

self._queue=queue

defrun(self):

whileTrue:

# queue.get blocks the current thread until

# an item is retrieved.

msg=self._queue.get

# Checks if the current message is

# the "Poison Pill"

ifisinstance(msgstr)andmsg=='quit':

# if so, exists the loop

break

# "Processes" (or in our case, prints) the queue item

print"I'm a thread, and I received %s!!"%msg

# Always be friendly!

print'Bye byes!'

defProducer:

# Queue is used to share items between

# the threads.

queue=Queue.Queue

# Create an instance of the worker

worker=Consumer(queue)

# start calls the internal run method to

# kick off the thread

worker.start

# variable to keep track of when we started

start_time=time.time

# While under 5 seconds..

whiletime.time-start_time

# "Produce" a piece of work and stick it in

# the queue for the Consumer to process

queue.put('something at %s'%time.time)

# Sleep a bit just to avoid an absurd number of messages

time.sleep(1)

# This the "poison pill" method of killing a thread.

queue.put('quit')

# wait for the thread to close down

worker.join

if__name__=='__main__':

Producer

哈，看起来有些像Java不是吗？

我并不是说使用生产者/消费者模型处理多线程/多进程任务是错误的（事实上，这一模型自有其用武之地）。只是，处理日常脚本任务时我们可以使用更有效率的模型。

问题在于…

首先，你需要一个样板类；

其次，你需要一个队列来传递对象；

而且，你还需要在通道两端都构建相应的方法来协助其工作（如果需想要进行双向通信或是保存结果还需要再引入一个队列）。

worker越多，问题越多

按照这一思路，你现在需要一个 worker线程的线程池。下面是一篇IBM经典教程中的例子——在进行网页检索时通过多线程进行加速。

#Example2.py

'''

A more realistic threadpoolexample

'''

importtime

importthreading

importQueue

importurllib2

classConsumer(threading.Thread):

def__init__(selfqueue):

threading.Thread.__init__(self)

self._queue=queue

defrun(self):

whileTrue:

content=self._queue.get

ifisinstance(contentstr)andcontent=='quit':

break

response=urllib2.urlopen(content)

print'Bye byes!'

defProducer:

urls=[

'http://python.org''http://yahoo'

'http://scala.org''http://google'

# etc..

]

queue=Queue.Queue

worker_threads=build_worker_pool(queue4)

start_time=time.time

# Add the urls to process

forurlinurls:

queue.put(url)

# Add thepoison pillv

forworkerinworker_threads:

queue.put('quit')

forworkerinworker_threads:

worker.join

print'Done! Time taken: {}'.format(time.time-start_time)

defbuild_worker_pool(queuesize):

workers=

for_inrange(size):

worker=Consumer(queue)

worker.start

workers.append(worker)

returnworkers

if__name__=='__main__':

Producer

这段代码能正确的运行，但仔细看看我们需要做些什么：构造不同的方法、追踪一系列的线程，还有为了解决恼人的死锁问题，我们需要进行一系列的 join操作。这还只是开始……

至此我们回顾了经典的多线程教程，多少有些空洞不是吗？样板化而且易出错，这样事倍功半的风格显然不那么适合日常使用，好在我们还有更好的方法。

何不试试 map

map这一小巧精致的函数是简捷实现 Python程序并行化的关键。map源于Lisp这类函数式编程语言。它可以通过一个序列实现两个函数之间的映射。

urls=['http://yahoo''http://reddit']

results=map(urllib2.urlopenurls)

上面的这两行代码将 urls这一序列中的每个元素作为参数传递到 urlopen方法中，并将所有结果保存到 results这一列表中。其结果大致相当于：

results=

forurlinurls:

results.append(urllib2.urlopen(url))

map函数一手包办了序列操作、参数传递和结果保存等一系列的操作。

为什么这很重要呢？这是因为借助正确的库，map可以轻松实现并行化操作。

在 Python中有个两个库包含了 map函数： multiprocessing和它鲜为人知的子库 multiprocessing.dummy.

这里多扯两句： multiprocessing.dummy？ mltiprocessing库的线程版克隆？这是虾米？即便在 multiprocessing库的官方文档里关于这一子库也只有一句相关描述。而这句描述译成人话基本就是说:"嘛，有这么个东西，你知道就成."相信我，这个库被严重低估了！

dummy是 multiprocessing模块的完整克隆，唯一的不同在于 multiprocessing作用于进程，而 dummy模块作用于线程（因此也包括了 Python所有常见的多线程限制）。

所以替换使用这两个库异常容易。你可以针对 IO密集型任务和 CPU密集型任务来选择不同的库。

动手尝试

使用下面的两行代码来引用包含并行化 map函数的库：

frommultiprocessingimportPool

frommultiprocessing.dummyimportPoolasThreadPool

实例化 Pool对象：

pool=ThreadPool

这条简单的语句替代了 example2.py中 buildworkerpool函数 7行代码的工作。它生成了一系列的 worker线程并完成初始化工作、将它们储存在变量中以方便访问。

Pool对象有一些参数，这里我所需要关注的只是它的第一个参数：processes.这一参数用于设定线程池中的线程数。其默认值为当前机器 CPU的核数。

一般来说，执行 CPU密集型任务时，调用越多的核速度就越快。但是当处理网络密集型任务时，事情有有些难以预计了，通过实验来确定线程池的大小才是明智的。

pool=ThreadPool(4)# Sets the pool size to 4

线程数过多时，切换线程所消耗的时间甚至会超过实际工作时间。对于不同的工作，通过尝试来找到线程池大小的最优值是个不错的主意。

创建好 Pool对象后，并行化的程序便呼之欲出了。我们来看看改写后的 example2.py

importurllib2

frommultiprocessing.dummyimportPoolasThreadPool

urls=[

'http://python.org'

'http://python.org/about/'

'http://onlamp/pub/a/python/2003/04/17/metaclasses.html'

'http://python.org/doc/'

'http://python.org/download/'

'http://python.org/getit/'

'http://python.org/community/'

'https://wiki.python.org/moin/'

'http://planet.python.org/'

'https://wiki.python.org/moin/LocalUserGroups'

'http://python.org/psf/'

'http://docs.python.org/devguide/'

'http://python.org/community/awards/'

# etc..

]

# Make the Pool of workers

pool=ThreadPool(4)

# Open the urls in their own threads

# and return the results

results=pool.map(urllib2.urlopenurls)

#close the pool and wait for the work to finish

pool.close

pool.join

实际起作用的代码只有 4行，其中只有一行是关键的。map函数轻而易举的取代了前文中超过 40行的例子。为了更有趣一些，我统计了不同方法、不同线程池大小的耗时情况。

# results =

# for url in urls:

# result = urllib2.urlopen(url)

# results.append(result)

# # ------- VERSUS ------- #

# # ------- 4 Pool ------- #

# pool = ThreadPool(4)

# results = pool.map(urllib2.urlopen, urls)

# # ------- 8 Pool ------- #

# pool = ThreadPool(8)

# # ------- 13 Pool ------- #

# pool = ThreadPool(13)

结果：

# Singlethread: 14.4 Seconds

# 4 Pool: 3.1 Seconds

# 8 Pool: 1.4 Seconds

# 13 Pool: 1.3 Seconds

很棒的结果不是吗？这一结果也说明了为什么要通过实验来确定线程池的大小。在我的机器上当线程池大小大于 9带来的收益就十分有限了。

另一个真实的例子

生成上千张图片的缩略图

这是一个 CPU密集型的任务，并且十分适合进行并行化。

基础单进程版本

importos

importPIL

frommultiprocessingimportPool

fromPILimportImage

SIZE=(7575)

SAVE_DIRECTORY='thumbs'

defget_image_paths(folder):

return(os.path.join(folderf)

forfinos.listdir(folder)

if'jpeg'inf)

defcreate_thumbnail(filename):

im=Image.open(filename)

im.thumbnail(SIZEImage.ANTIALIAS)

basefname=os.path.split(filename)

save_path=os.path.join(baseSAVE_DIRECTORYfname)

im.save(save_path)

if__name__=='__main__':

folder=os.path.abspath(

'11_18_2013_R000_IQM_Big_Sur_Mon__e10d1958e7b766c3e840')

os.mkdir(os.path.join(folderSAVE_DIRECTORY))

images=get_image_paths(folder)

forimageinimages:

create_thumbnail(Image)

上边这段代码的主要工作就是将遍历传入的文件夹中的图片文件，一一生成缩略图，并将这些缩略图保存到特定文件夹中。

这我的机器上，用这一程序处理 6000张图片需要花费 27.9秒。

如果我们使用 map函数来代替 for循环：

importos

importPIL

frommultiprocessingimportPool

fromPILimportImage

SIZE=(7575)

SAVE_DIRECTORY='thumbs'

defget_image_paths(folder):

return(os.path.join(folderf)

forfinos.listdir(folder)

if'jpeg'inf)

defcreate_thumbnail(filename):

im=Image.open(filename)

im.thumbnail(SIZEImage.ANTIALIAS)

basefname=os.path.split(filename)

save_path=os.path.join(baseSAVE_DIRECTORYfname)

im.save(save_path)

if__name__=='__main__':

folder=os.path.abspath(

'11_18_2013_R000_IQM_Big_Sur_Mon__e10d1958e7b766c3e840')

os.mkdir(os.path.join(folderSAVE_DIRECTORY))

images=get_image_paths(folder)

pool=Pool

pool.map(creat_thumbnailimages)

pool.close

pool.join

5.6秒！

虽然只改动了几行代码，我们却明显提高了程序的执行速度。在生产环境中，我们可以为 CPU密集型任务和 IO密集型任务分别选择多进程和多线程库来进一步提高执行速度——这也是解决死锁问题的良方。此外，由于 map函数并不支持手动线程管理，反而使得相关的 debug工作也变得异常简单。

到这里，我们就实现了（基本）通过一行Python实现并行化。

Update:

译文已获作者 Chris授权

题图：pexels，CC0授权。

首先你要了解一下Python之禅，一行代码输出“The Zen of Python”：

python -c "importthis""""The Zen of Python, by Tim PetersBeautiful is better than ugly.Explicit is better than implicit.Simple is better than complex.Complex is better than complicated.Flat is better than nested.Sparse is better than dense.Readability counts.Special cases aren't special enough to break the rules.Although practicality beats purity.Errors should never pass silently.Unless explicitly silenced.In the face ofambiguity, refuse thetemptationto guess.There should be one-- and preferably only one --obvious way to do it.Although that way may not be obvious at first unless you're Dutch.Now is better than never.Although never is often better than *right* now.If theimplementationis hard toexplain, it's a bad idea.If theimplementationis easy toexplain, it may be a good idea.Namespaces are one honking great idea -- let's do more of those!"""

从“The Zen of Python”也能看出，Python倡导Beautiful、Explicit、Simple等原则，当然我们接下来要介绍的一行Python能实现哪些好玩的功能，可能和Explicit原则相违背。

（1）一行代码启动一个Web服务

python -m SimpleHTTPServer 8080 # python2python3 -m http.server 8080 #python3

（2）一行代码实现变量值互换

a, b = 1, 2; a, b = b, a

（3）一行代码解决FizzBuzz问题:

FizzBuzz问题：打印数字1到100, 3的倍数打印“Fizz”, 5的倍数打印“Buzz”,既是3又是5的倍数的打印“FizzBuzz”

for x in range(1, 101): print("fizz"[x % 3 * 4:]+"buzz"[x % 5 * 4:] or x)

（4）一行代码输出特定字符"Love"拼成的心形

print(' '.join([''.join([('Love'[(x-y) % len('Love')] if ((x*0.05)**2+(y*0.1)**2-1)**3-(x*0.05)**2*(y*0.1)**3

（5）一行代码输出Mandelbrot图像

Mandelbrot图像：图像中的每个位置都对应于公式N=x+y*i中的一个复数

print(' '.join([''.join(['*'if abs((lambda a: lambda z, c, n: a(a, z, c, n))(lambda s, z, c, n: z if n == 0 else s(s, z*z+c, c, n-1))(0, 0.02*x+0.05j*y, 40))

（6）一行代码打印九九乘法表

print(' '.join([' '.join(['%s*%s=%-2s' % (y, x, x*y) for y in range(1, x+1)]) for x in range(1, 10)]))

（7）一行代码计算出1-100之间的素数(两个版本)

print(' '.join([str(item) for item in filter(lambda x: not [x % i for i in range(2, x) if x % i == 0], range(2, 101))]))print(' '.join([str(item) for item in filter(lambda x: all(map(lambda p: x % p != 0, range(2, x))), range(2, 101))]))

（8）一行代码输出斐波那契数列

print([x[0] for x in [(a[i][0], a.append([a[i][1], a[i][0]+a[i][1]])) for a in ([[1, 1]], ) for i in range(30)]])

（9）一行代码实现快排算法

qsort =lambda arr: len(arr) > 1 and qsort(list(filter(lambda x: x arr[0], arr[1:]))) or arr

（10）一行代码解决八皇后问题

[__import__('sys').stdout.write(' '.join('.' * i + 'Q' + '.' * (8-i-1) for i in vec) + " ======== ") for vec in __import__('itertools').permutations(range(8)) if 8 == len(set(vec[i]+i for i in range(8))) == len(set(vec[i]-i for i in range(8)))]

（11）一行代码实现数组的flatten功能:将多维数组转化为一维

flatten = lambda x: [y for l in x for y in flatten(l)] if isinstance(x, list) else [x]

（12）一行代码实现list,有点类似与上个功能的反功能

array = lambda x: [x[i:i+3] for i in range(0, len(x), 3)]

（13）一行代码实现求解2的1000次方的各位数之和

用过手机QQ就知道，点击一个图片会弹出一个小功能，那就是提取图片中的文字。非常方便实用，那么很难实现吗？

利用Python提取图片中的文字信息，只需要一行代码就能搞定！

当然，这是吹牛皮的，但是真正的Python代码也就第4行，说是一行代码搞定也没错。

示例：

效果

尽管运行Python代码后也有几个错误的地方，但是大部分是识别正确的。你以为就这样结束了吗？那这么简单，我都不用出教程了。一行代码实现这个功能当然也是要有前戏的。

一，pytesseract和PIL的安装

pip安装

2，pycharm编辑器能够快速安装，这就看你是否用pycharm了。

pycharm的Settings设置页按照下面步骤操作

安装好了pytesseract，安装PIL在上面第三步里搜索PIL并点击安装就可以了。

安装好了所有库，运行下面Python代码

出现报错

可以看到提示：未安装识别引擎tesseract-ocr

二，安装识别引擎tesseract-ocr

1.网上下载安装包，然后直接点击安装即可

因为tesseract-ocr默认不支持中文识别，所以解压安装tesseract-ocr后还需做如下操作

2，安装完成tesseract-ocr后，我们还需配置好

打开后做如下操作

当然也能由pycharm快速打开pytesseract.py

第一步：

第二步：

第三步：

现在已经完成了所有配置，运行下面Python代码即可实现图片里的文字提取

本文到此就结束了，希望各位Python越学越好，早日达成梦想。