Python编程实战：热门技巧与示例

需积分: 6 38 浏览量更新于2024-07-17 收藏 2.04MB PDF 举报

"《Python Programming Cookbook》是一本深入实践的Python编程指南，涵盖了从基础到高级的各种主题。书中包含了一系列实用的示例，包括CSV读写、装饰器、多线程并发、日志记录、Django框架教程、字典操作、套接字编程、映射函数、子进程管理和发送邮件等。" 在Python编程中，这本书提供了丰富的知识点： 1. **CSV Reader / Writer Example**：Python提供了`csv`模块来处理CSV文件。基本用法包括打开、读取和写入CSV数据。你可以读取行数据并将其转换为字典，或者将数据结构化后写入CSV文件，这对于数据导入导出非常有用。 2. **Decorator Tutorial**：装饰器是Python中强大的元编程工具，用于修改或增强函数、类或其他对象的行为。它们通过在定义体前加上`@decorator`语法来使用。书中会介绍如何创建自定义装饰器，以及如何使用内置的装饰器如`@staticmethod`和`@classmethod`。 3. **Threading / Concurrency Example**：Python提供了`threading`和`_thread`模块来实现多线程。书中详细讲解了如何创建和管理线程，包括线程同步（如锁、事件、信号量）和守护线程的概念，以及如何限制资源并发访问，确保线程安全。 4. **Logging Example**：Python的`logging`模块用于生成程序运行的日志。书中介绍了日志级别（如DEBUG、INFO、WARNING、ERROR、CRITICAL），如何设置处理器和格式，以及如何在实践中应用日志记录。 5. **Django Tutorial**：Django是流行的Python Web框架，用于快速开发安全且可维护的网站。教程将指导读者创建项目、定义应用、配置数据库、创建模型、URL路由和视图，以及模板系统，帮助理解Django的工作流程。 6. **Dictionary Example**：Python字典是关联数组，提供键值对的高效存储。书中可能会涵盖字典操作，如添加、删除元素，迭代，以及使用`defaultdict`和`items()`等高级特性。 7. **Sockets Example**：Python的`socket`模块允许进行网络通信。通过实例，读者可以学习如何创建客户端和服务器，进行TCP和UDP通信，实现网络数据交换。 8. **Map Example**：`map()`函数可以应用于列表或其他可迭代对象，将一个函数应用于所有元素并返回结果的列表。这个例子可能展示如何高效地使用`map()`进行函数式编程。 9. **Subprocess Example**：Python的`subprocess`模块用于启动新的进程，连接到其输入/输出/错误管道，并获取其返回码。书中可能涵盖如何执行外部命令，捕获输出，以及进程间通信。 10. **Send Email Example**：Python的`smtplib`和`email`库可用于发送电子邮件。例子可能涉及创建邮件消息，设置发件人、收件人，连接SMTP服务器，以及发送带有附件的邮件。这些示例提供了全面的Python开发经验，从数据处理到Web开发，再到系统级交互，对任何Python开发者来说都是一份宝贵的资源。通过学习和实践这些"热菜谱"，开发者可以提升技能，解决实际问题。

Python Programming Cookbook 7 / 80

Chapter 2

Decorator Tutorial

Sometimes, we encounter problems that require us to extend the behavior of a function, but we don’t want to change its im-

plementation.Some of those problems could be: logging spent time, caching, validating parameters, etc. All these solutions are

often needed in more than one function: you often need to log the spent time of every http connection; you often need to cache

more than one data base entity; you often need validation in more than one function. Today we will solve these 3 mentioned

problems with Python decorators:

• Spent Time Logging: We’ll decorate a couple functions to tell us how much time do they take to execute.

• Caching: We’ll add cache to prevent a function from executing when its called several times with the same parameters.

• Validating: We’ll validate a function’s input to prevent run time errors.

2.1 Understanding Functions

Before we can jump into decorators, we need to understand how functions actually work. In essence, functions are procedures

that return a value based on some given arguments.

def my_function(my_arg):

return my_arg + 1

In Python, functions are ﬁrst-class objects. This means that functions can be assigned to a variable:

def my_function(foo):

return foo + 1

my_var = my_function

print(str(my_var(1))) # prints "2"

They can be deﬁned inside another functions:

def my_function(foo):

def my_inner_function():

return 1

return foo + my_inner_function()

print(str(my_function(1))) # still prints "2"

They can be passed as parameters (higher-order functions):

def my_function(foo, my_parameter_function):

return foo + my_parameter_function()

def parameter_function(): return 1

print(str(my_function(1, parameter_function))) # still prints "2"

Python Programming Cookbook 8 / 80

And they can return other functions (also, higher-order functions):

def my_function(constant):

def inner(foo):

return foo + constant

return inner

plus_one = my_function(1)

print(str(plus_one(1))) # still prints "2"

Another thing to notice, is that inner functions have access to the outer scope, that’s why we can use the parameter constant

in the inner function of the last example. Also, this access is read-only, we can not modify variables from the outer scope within

an inner function.

2.2 Jumping into decorators

Python decorators provide a nice and simple syntax to call higher-order functions. By deﬁnition, a decorator takes a function as a

parameter, and returns a wrapper of that given function to extend its behavior without actually modifying it. Given this deﬁnition

we can write somthing like:

def decorator(function_to_decorate):

def wrapper(value):

print("you are calling {} with ’{}’ as parameter".format(function_to_decorate. ←-

__name__, value))

return function_to_decorate(value)

return wrapper

def replace_commas_with_spaces(value):

return value.replace(",", " ")

function_to_use = decorator(replace_commas_with_spaces)

print(function_to_use("my,commas,will,be,replaces,with,spaces"))

And after execution, the output will look like:

you are calling replace_commas_with_spaces with ’my,commas,will,be,replaces,with,spaces’ as ←-

parameter

my commas will be replaces with spaces

So, what is actually happening here? We are deﬁning a higher-order function called decorator that receives a function as a

parameter and returns a wrapper of that function. The wrapper just prints to the console the name of the called function and the

given parameters before executing the wrapped function. And the wrapped functions just replaces the commas with spaces. Now

we have a decorator written here. But it’s kind of annoying to deﬁne the decorator, the function and then assigning the wrapper

to another variable to ﬁnally be able to use it. Python provides some sugar syntax to make it easier to write and read, and if we

re-write this decorator using it:

def decorator(function_to_decorate):

def wrapper(value):

print("you are calling {} with ’{}’ as parameter".format(function_to_decorate. ←-

__name__, value))

return function_to_decorate(value)

return wrapper

@decorator

def replace_commas_with_spaces(value):

return value.replace(",", " ")

print(replace_commas_with_spaces.__name__)

Python Programming Cookbook 9 / 80

print(replace_commas_with_spaces.__module__)

print(replace_commas_with_spaces.__doc__)

print(replace_commas_with_spaces("my,commas,will,be,replaces,with,spaces"))

We just annotate the function we want to wrap with the decorator function and that’s it. That function will be decorated, and the

output will look the same.

wrapper

__main__

None

you are calling replace_commas_with_spaces with ’my,commas,will,be,replaces,with,spaces’ as ←-

parameter

my commas will be replaces with spaces

Now, debugging this can be a real pain, as the replace_commas_with_spaces function is overridden with the wrapper,

so its __name__, __doc__ and __module__ will also be overridden (as seen in the output). To avoid this behavior we will

use functools.wraps, that prevents a wrapper from overriding its inner function properties.

from functools import wraps

def decorator(function_to_decorate):

@wraps(function_to_decorate)

def wrapper(value):

print("you are calling {} with ’{}’ as parameter".format(function_to_decorate. ←-

__name__, value))

return function_to_decorate(value)

return wrapper

@decorator

def replace_commas_with_spaces(value):

return value.replace(",", " ")

print(replace_commas_with_spaces.__name__)

print(replace_commas_with_spaces.__module__)

print(replace_commas_with_spaces.__doc__)

print(replace_commas_with_spaces("my,commas,will,be,replaces,with,spaces"))

And now the output will be:

replace_commas_with_spaces

__main__

None

you are calling replace_commas_with_spaces with ’my,commas,will,be,replaces,with,spaces’ as ←-

parameter

my commas will be replaces with spaces

So, now we know how decorators work in python. Let’s solve our mentioned problems.

2.3 The Practice

So, we need to implement cache, spent time logging and validations. Let’s combine them all by solving a bigger problem:

palindromes. Let’s make an algorithm that, given a word, will check if it’s a palindrome. If it isn’t, it will convert it to

palindrome. palindrome.py

def is_palindrome(string_value):

char_array = list(string_value)

size = len(char_array)

Python Programming Cookbook 10 / 80

half_size = int(size / 2)

for i in range(0, half_size):

if char_array[i] != char_array[size - i - 1]:

return False

return True

def convert_to_palindrome(v):

def action(string_value, chars):

chars_to_append = list(string_value)[0:chars]

chars_to_append.reverse()

new_value = string_value + "".join(chars_to_append)

if not is_palindrome(new_value):

new_value = action(string_value, chars + 1)

return new_value

return action(v, 0)

user_input = input("string to convert to palindrome (exit to terminate program): ")

while user_input != "exit":

print(str(convert_to_palindrome(user_input)))

user_input = input("string to check (exit to terminate program): ")

Here, we have a function called is_palindrome, which given an input, returns True if its palindrome, or False otherwise.

Then, there is a function called convert_to_palindrome which, given an input, will add just as many characters (reversed,

from the beginning) as necessary to make it palindrome. Also, there is a while that reads the user input until he inputs "exit".

The output looks like:

string to convert to palindrome (exit to terminate program): anita lava la tina

anita lava la tinanit al aval atina

string to check (exit to terminate program): anitalavalatina

anitalavalatina

string to check (exit to terminate program): menem

menem

string to check (exit to terminate program): mene

menem

string to check (exit to terminate program): casa

casac

string to check (exit to terminate program): casaca

casacasac

string to check (exit to terminate program): exit

As you can see, it works just ﬁne. But we have a couple problems:

• I don’t know how long does it take it to process the input, or if its related to the length of it. (spent time logging)

• I don’t want it to process twice the same input, it’s not necessary. (cache)

• It’s designed to work with words or numbers, so I don’t want spaces around. (validation)

Let’s get dirty here, and start with a spent time logging decorator.

palindrome.py

import datetime

from functools import wraps

def spent_time_logging_decorator(function):

@wraps(function)

def wrapper(

args):

start = datetime.datetime.now()

result = function(

args)

剩余87页未读，继续阅读

marc47marc47

粉丝: 2
资源: 7

Python编程实战：热门技巧与示例

最新资源