深入理解Python：Python Cookbook实战指南

需积分: 10 130 浏览量更新于2024-07-24 收藏 3.62MB PDF 举报

"Python Cookbook" 是一本面向有经验的Python程序员的书籍，旨在深化读者对Python语言和现代编程模式的理解。书中重点介绍了一些库、框架和应用中使用的高级技术，并假设读者已经具备必要的计算机科学、数据结构、复杂性、系统编程、并发性和C编程等基础知识。书中的“配方”通常只是提供基础信息的骨架，需要读者自行深入研究以填补细节。通过阅读，读者将获得更深入的Python工作原理理解，学习新的技巧和方法，以应用于自己的代码。本书的内容涵盖了Python的多个高级主题，包括但不限于： 1. **类型和操作符**：探讨Python的内置类型如列表、元组、字典和集合的高效使用，以及如何自定义类型和实现操作符重载。 2. **函数和模块**：讲解函数式编程概念，如高阶函数、闭包、装饰器和迭代器，以及如何组织和导入模块。 3. **面向对象编程**：讨论类、继承、多态、元类和属性的用法，以及如何设计和实现面向对象的解决方案。 4. **错误和异常处理**：介绍异常处理机制，如何优雅地捕获和处理错误，以及使用try/except/finally语句进行资源管理。 5. **字符串和文本处理**：涵盖字符串格式化、正则表达式、文本分词和编码处理等。 6. **数据结构优化**：讲解如何有效地利用Python的数据结构，如链表、堆栈和队列，以及如何自定义复杂数据结构。 7. **并发和多线程**：介绍Python的并发模型，如GIL（全局解释器锁）和线程、进程，以及异步I/O。 8. **性能调优**：探讨Python的性能分析工具，以及如何通过代码优化提高程序执行效率。 9. **元编程**：讨论如何在运行时修改和创建Python对象，包括动态类型和元类的应用。 10. **网络和系统编程**：涉及网络通信、文件和文件系统操作，以及与操作系统交互的API。 11. **标准库的深入使用**：详细介绍Python标准库中的各种模块，如os、sys、time、json等，以及它们在实际项目中的应用。 12. **测试和调试**：介绍单元测试、集成测试和调试技巧，帮助确保代码的质量和可靠性。本书的电子版还提供了DRM-free格式，可以在多种设备上无限制使用，并支持Dropbox同步，便于读者随时随地学习。对于从其他零售商购买电子书的用户，可以通过升级获取这些额外福利。 "Python Cookbook" 是一本深度和技术并重的书籍，适合希望提升Python编程技能和理解的开发者，尤其是那些已经在实践中积累了经验并寻求进一步提升的程序员。通过这本书，读者不仅可以学习到具体的编程技巧，还能了解到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页未读，继续阅读

Morphad

粉丝: 26
资源: 8

深入理解Python：Python Cookbook实战指南

PythonCookbook3高清.pdf

Python Cookbook 英文版.pdf

python cookbook 第3版 高清 pdf

time series analysis with python cookbook

python cookbook 第三版

python cookbook csdn

pythoncookbook

python cookbook pdf

python cookbook第四版

ironpython教程_IronPython教程

最新资源

python cookbook 第3版高清 pdf