Python Cookbook第3版电子书升级特惠：兼容与未来趋势

5星 · 超过95%的资源需积分: 10 50 浏览量更新于2024-07-23 收藏 3.62MB PDF 举报

《Python Cookbook第三版》是一本专门针对Python编程语言的实用指南，由David Beazley和Brian K. Jones合著。该书在英文版中发布，旨在帮助读者解决在Python开发过程中遇到的各种复杂问题和高级技术挑战。本书的核心价值在于其丰富的实例和深入的剖析，适合经验丰富的Python开发者以及想要提升技能的程序员。自2008年以来，Python社区一直在关注Python 3的渐进式演进，尽管它与早期版本不完全兼容，但随着时间的推移，越来越多的人开始转向Python 3以利用其改进的语言特性。即使在2013年，许多职业开发者仍在使用Python 2进行生产环境开发，这表明迁移过程中的顾虑主要是由于对新版本兼容性的担忧。 Python 3的不兼容性主要体现在语法和模块层面，但这并不是绝对的障碍，因为开发者可以通过适当的方法处理旧代码以适应新版本。实际上，Python 3带来了许多优点，如改进的数据类型、增强的性能、更好的错误处理和统一的编码规则，这些都使得长期投资于新版本的学习和实践变得更有价值。对于已经购买了电子版《Python Cookbook第三版》的读者，特别是从O'Reilly官网直接购买的用户，他们享受到了无限制跨设备使用的DRM-free电子书、多格式支持（包括电脑、平板和手机）、终身访问并可免费更新的权利，以及Dropbox同步功能，方便他们在任何地方存取文件。如果是在其他零售商处购买的用户，他们可以通过付费升级（仅需$4.99）来获取上述所有优势。本书的预览部分强调了作者对于Python 3演进的看法，并提醒读者在面对迁移时，除了考虑兼容性问题外，还应关注Python 3带来的新特性和潜在优势，以便做出更明智的技术决策。此外，书中详细介绍了各种实用技巧和解决方案，涵盖了诸如网络编程、并发、数据结构优化、元编程等主题，旨在帮助读者提高编程效率和代码质量。《Python Cookbook第三版》是一本既实用又具有前瞻性的重要资源，无论是为了熟悉Python 3的最佳实践，还是深入理解如何解决实际编程问题，都能从中受益匪浅。对于希望在Python领域持续发展的专业人士来说，这是一本不可或缺的参考书籍。

def do_bar(s):

print('bar', s)

for tag, *args in records:

if tag == 'foo':

do_foo(*args)

elif tag == 'bar':

do_bar(*args)

Star unpacking can also be useful when combined with certain kinds of string processing operations,

such as splitting. For example:

>>> line = 'nobody:*:-2:-2:Unprivileged User:/var/empty:/usr/bin/false'

>>> uname, *fields, homedir, sh = line.split(':')

>>> uname

'nobody'

>>> homedir

'/var/empty'

>>> sh

'/usr/bin/false'

>>>

Sometimes you might want to unpack values and throw them away. You can’t just specify a bare *

when unpacking, but you could use a common throwaway variable name, such as _ or ign (ignored).

For example:

>>> record = ('ACME', 50, 123.45, (12, 18, 2012))

>>> name, *_, (*_, year) = record

>>> name

'ACME'

>>> year

2012

>>>

There is a certain similarity between star unpacking and list-processing features of various functional

languages. For example, if you have a list, you can easily split it into head and tail components like

this:

>>> items = [1, 10, 7, 4, 5, 9]

>>> head, *tail = items

>>> head

>>> tail

[10, 7, 4, 5, 9]

>>>

One could imagine writing functions that perform such splitting in order to carry out some kind of

clever recursive algorithm. For example:

>>> def sum(items):

... head, *tail = items

... return head + sum(tail) if tail else head

...

>>> sum(items)

>>>

However, be aware that recursion really isn’t a strong Python feature due to the inherent recursion

limit. Thus, this last example might be nothing more than an academic curiosity in practice.

1.3. Keeping the Last N Items

Problem

You want to keep a limited history of the last few items seen during iteration or during some other

kind of processing.

Solution

Keeping a limited history is a perfect use for a collections.deque. For example, the following code

performs a simple text match on a sequence of lines and yields the matching line along with the

previous N lines of context when found:

from collections import deque

def search(lines, pattern, history=5):

previous_lines = deque(maxlen=history)

for line in lines:

if pattern in line:

yield line, previous_lines

previous_lines.append(line)

# Example use on a file

if __name__ == '__main__':

with open('somefile.txt') as f:

for line, prevlines in search(f, 'python', 5):

for pline in prevlines:

print(pline, end='')

print(line, end='')

print('-'*20)

Discussion

When writing code to search for items, it is common to use a generator function involving yield, as

shown in this recipe’s solution. This decouples the process of searching from the code that uses the

results. If you’re new to generators, see Recipe 4.3.

Using deque(maxlen=N) creates a fixed-sized queue. When new items are added and the queue is full,

the oldest item is automatically removed. For example:

>>> q = deque(maxlen=3)

>>> q.append(1)

>>> q.append(2)

>>> q.append(3)

>>> q

deque([1, 2, 3], maxlen=3)

>>> q.append(4)

>>> q

deque([2, 3, 4], maxlen=3)

>>> q.append(5)

>>> q

deque([3, 4, 5], maxlen=3)

Although you could manually perform such operations on a list (e.g., appending, deleting, etc.), the

queue solution is far more elegant and runs a lot faster.

More generally, a deque can be used whenever you need a simple queue structure. If you don’t give it

a maximum size, you get an unbounded queue that lets you append and pop items on either end. For

example:

>>> q = deque()

>>> q.append(1)

>>> q.append(2)

>>> q.append(3)

>>> q

deque([1, 2, 3])

>>> q.appendleft(4)

>>> q

deque([4, 1, 2, 3])

>>> q.pop()

1.4. Finding the Largest or Smallest N Items

Problem

You want to make a list of the largest or smallest N items in a collection.

Solution

The heapq module has two functions—nlargest() and nsmallest()—that do exactly what you

want. For example:

import heapq

nums = [1, 8, 2, 23, 7, -4, 18, 23, 42, 37, 2]

print(heapq.nlargest(3, nums)) # Prints [42, 37, 23]

print(heapq.nsmallest(3, nums)) # Prints [-4, 1, 2]

Both functions also accept a key parameter that allows them to be used with more complicated data

structures. For example:

portfolio = [

{'name': 'IBM', 'shares': 100, 'price': 91.1},

{'name': 'AAPL', 'shares': 50, 'price': 543.22},

{'name': 'FB', 'shares': 200, 'price': 21.09},

{'name': 'HPQ', 'shares': 35, 'price': 31.75},

{'name': 'YHOO', 'shares': 45, 'price': 16.35},

{'name': 'ACME', 'shares': 75, 'price': 115.65}

]

cheap = heapq.nsmallest(3, portfolio, key=lambda s: s['price'])

expensive = heapq.nlargest(3, portfolio, key=lambda s: s['price'])

Discussion

If you are looking for the N smallest or largest items and N is small compared to the overall size of

the collection, these functions provide superior performance. Underneath the covers, they work by

first converting the data into a list where items are ordered as a heap. For example:

>>> nums = [1, 8, 2, 23, 7, -4, 18, 23, 42, 37, 2]

>>> import heapq

>>> heap = list(nums)

>>> heapq.heapify(heap)

>>> heap

[-4, 2, 1, 23, 7, 2, 18, 23, 42, 37, 8]

>>>

The most important feature of a heap is that heap[0] is always the smallest item. Moreover,

subsequent items can be easily found using the heapq.heappop() method, which pops off the first

item and replaces it with the next smallest item (an operation that requires O(log N) operations where

N is the size of the heap). For example, to find the three smallest items, you would do this:

>>> heapq.heappop(heap)

-4

>>> heapq.heappop(heap)

The nlargest() and nsmallest() functions are most appropriate if you are trying to find a relatively

small number of items. If you are simply trying to find the single smallest or largest item (N=1), it is

faster to use min() and max(). Similarly, if N is about the same size as the collection itself, it is

usually faster to sort it first and take a slice (i.e., use sorted(items)[:N] or sorted(items)[-N:]).

It should be noted that the actual implementation of nlargest() and nsmallest() is adaptive in how

it operates and will carry out some of these optimizations on your behalf (e.g., using sorting if N is

close to the same size as the input).

Although it’s not necessary to use this recipe, the implementation of a heap is an interesting and

worthwhile subject of study. This can usually be found in any decent book on algorithms and data

剩余677页未读，继续阅读

robinej

粉丝: 0
资源: 1

Python Cookbook第3版电子书升级特惠：兼容与未来趋势

Python Cookbook（第3版）中文版.pdf 极清PDF

python cookbook 第三版中文版

《Python Cookbook》第三版中文v1.0.2.mobi

Python Cookbook第三版：中英文版本对比学习指南

python cookbook 3th

openCV3 CookBook 第三版英文版和第一版

Python Cookbook, 2013 3rd Edition David Beazley

pythondbReilly_Python_Cookbook

Python核心编程第二版.pdf

python cook book

最新资源