Python Cookbook第三版：掌握最新Python语法

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

"Python Cookbook第三版，电子书pdf版本，主要介绍python最新的语法和更新的内容" Python Cookbook第三版是由David Beazley和Brian K. Jones共同编写的，这是一本深受Python开发者喜爱的实用指南，专注于解决Python编程中的实际问题。本书针对Python 3进行了全面的更新，涵盖了Python 3的最新语法和特性，旨在帮助程序员提高效率，优化代码，并提供了一系列实用的代码片段和最佳实践。在Python 3的演进过程中，尽管它与Python 2在向后兼容性上存在一些问题，但Python 3引入了许多显著的改进和新功能。例如，字符串处理方面，Python 3采用了统一的Unicode编码模型，使得处理文本数据更加方便；在语法层面，print语句被改为了函数，提高了代码的可读性和一致性；此外，异常处理的语法也有所改变，使用try/except/else/finally结构更加清晰。 Python 3中还引入了新的数据类型，如集合（set）和字典的更新操作。集合提供了快速的成员测试和唯一元素集合化，而字典的更新方法如dict.update()则允许更灵活的数据处理。此外，Python 3还增强了函数式编程的支持，如新增了yield from表达式，用于更好地实现生成器的嵌套和组合，以及内置的map(), filter()和reduce()等函数的改进。本书详细探讨了迭代器和生成器的使用，它们是Python高效内存管理和并发处理的关键。通过使用生成器，开发者可以编写出占用内存小但计算量大的程序，尤其是在处理大量数据时。此外，书中还讲解了上下文管理器（context manager），这是处理资源获取和释放（如文件操作或网络连接）的最佳实践。 Python 3的模块系统也得到了改进，导入语句可以更灵活地控制模块的加载。例如，使用importlib模块动态导入，以及使用from...import语句的星号导入（* import）来导入整个模块或子模块的内容。在性能优化方面，Python Cookbook介绍了各种技巧，如使用列表推导式替代循环，使用生成器表达式节省内存，以及如何利用Python的内置函数和标准库来提升代码速度。此外，书中还讨论了如何使用Cython或PyPy等工具将Python代码加速到接近C语言的速度。 Python Cookbook第三版是Python 3开发者不可或缺的参考书，无论你是初学者还是经验丰富的程序员，都可以从中学习到如何更有效地编写、理解和维护Python代码。通过这本书，你可以掌握Python 3的最新特性和最佳实践，提升你的编程技能和解决问题的能力。

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页未读，继续阅读

tianfangriyetan

粉丝: 0
资源: 1

Python Cookbook第三版：掌握最新Python语法

《Python Cookbook》第三版中文.pdf

python cookbook 3

Python Cookbook

python cookbook 第三版

python cookbook 第3版 高清 pdf

python cookbook pdf

python入门教程pdf

帮我统计几个python通讯录的参考文献

python书籍及第三方库

学习高等数学和Python的最佳学习资料，推荐10本相关的书籍

最新资源

python cookbook 第3版高清 pdf