Python编程指南：从入门到精通

需积分: 10 176 浏览量更新于2024-07-22 收藏 383KB PDF 举报

"Python Guide" 是一份由 Kenneth Reitz 编写的 Python 开发者文档，主要涵盖 Python 的入门、编写优质代码、场景指南以及代码发布等方面的知识，旨在帮助开发者更好地理解和应用 Python。 **1. Getting Started（入门）** 在入门部分，介绍了如何选择合适的解释器。对于初学者来说，理解 Python 解释器的不同版本（如 CPython、Jython、PyPy 等）及其特性是至关重要的。接着，文档详细讲解了在 MacOSX、Windows 和 Linux 上安装 Python 的步骤，包括如何获取 Python 安装包，以及如何设置环境变量。 **2. Writing Great Code（编写优质代码）** 这一部分深入讨论了编写高质量 Python 代码的实践方法。其中包括： - **Structuring Your Project（项目结构）**：建议遵循良好的文件组织原则，如使用 `__init__.py` 文件来创建包，合理划分模块等。 - **Code Style**：强调遵循 PEP 8 风格指南，这是 Python 社区广泛接受的编码规范。 - **Reading Great Code（阅读优质代码）**：鼓励学习和理解开源项目的代码，从中汲取经验。 - **Documentation（文档编写）**：提醒开发者重视代码注释和文档字符串，以便其他开发者能更容易地理解和使用代码。 - **Testing Your Code（测试代码）**：提倡使用单元测试、集成测试和持续集成工具来确保代码质量。 - **Logging（日志记录）**：讲解如何使用 Python 的内置 logging 模块进行错误追踪和调试。 - **Common Gotchas（常见陷阱）**：列举了一些常见的编程陷阱，帮助开发者避免潜在的问题。 - **Choosing a License（选择许可证）**：指导开发者如何为自己的项目选择合适的开源许可证。 **3. Scenario Guide（场景指南）** 这部分提供了针对不同应用场景的指导，如： - **Network Applications（网络应用）**：讲解如何使用 Python 进行网络编程，如套接字通信。 - **Web Applications（Web 应用）**：涵盖了 Web 开发框架如 Flask 和 Django 的使用。 - **HTML Scraping（网页抓取）**：介绍了如何使用 Python 进行网页数据抓取。 - **Command-line Applications（命令行应用）**：展示了如何构建交互式命令行程序。 - **GUI Applications（图形用户界面应用）**：提到了使用 Tkinter 或 PyQt 等库开发 GUI 的方法。 - **Databases（数据库）**：讲解如何与各种数据库（如 SQLite、MySQL、PostgreSQL）进行交互。 - **Networking（网络编程）**：涉及网络协议和套接字编程。 - **Systems Administration（系统管理）**：介绍了 Python 在自动化系统管理中的应用。 - **Continuous Integration（持续集成）**：探讨使用 Jenkins、Travis CI 等工具进行自动化测试和构建。 - **Speed（性能优化）**：讨论如何分析和优化 Python 代码的运行速度。 - **Scientific Applications（科学计算）**：介绍了 NumPy、SciPy 和 Pandas 等科学计算库。 - **Image Manipulation（图像处理）**：提到了 Pillow 和 OpenCV 等图像处理库。 - **XML Parsing（XML解析）**：解释如何使用 Python 处理 XML 数据。 - **JSON（JSON处理）**：展示了如何进行 JSON 编码和解码。 - **Cryptography（加密）**：介绍了 Python 中的加密库，如 PyCrypto 和 cryptography。 **4. Shipping Great Code（发布优质代码）** 这部分介绍如何打包和发布代码，包括创建 Python 包，以及使用 PyInstaller 等工具将代码冻成可执行文件。 **5. Development Environment（开发环境）** 讲解了如何设置个人开发环境，以及如何使用虚拟环境（如 venv 或 virtualenv）来隔离项目依赖。 **6. Additional Notes（附加注释）** 这部分可能包含作者的额外见解、更新或补充信息。这份 Python Guide 是一份全面的 Python 开发者参考手册，覆盖了从基础到高级的各种主题，适合从初学者到有经验的开发者阅读。

Python Guide Documentation, Release 0.0.1

However, unlike Java, Python does not impose object-oriented programming as the main programming paradigm. It

is perfectly viable for a Python project to not be object-oriented, i.e. to use no or very few class deﬁnitions, class

inheritance, or any other mechanisms that are speciﬁc to object-oriented programming.

Moreover, as seen in the modules section, the way Python handles modules and namespaces gives the developer a

natural way to ensure the encapsulation and separation of abstraction layers, both being the most common reasons to

use object-orientation. Therefore, Python programmers have more latitude to not use object-orientation, when it is not

required by the business model.

There are some reasons to avoid unnecessary object-orientation. Deﬁning custom classes is useful when we want to

glue together some state and some functionality. The problem, as pointed out by the discussions about functional

programming, comes from the “state” part of the equation.

In some architectures, typically web applications, multiple instances of Python processes are spawned to respond

to external requests that can happen at the same time. In this case, holding some state into instantiated objects,

which means keeping some static information about the world, is prone to concurrency problems or race-conditions.

Sometimes, between the initialization of the state of an object (usually done with the __init__() method) and the

actual use of the object state through one of its methods, the world may have changed, and the retained state may be

outdated. For example, a request may load an item in memory and mark it as read by a user. If another request requires

the deletion of this item at the same time, it may happen that the deletion actually occurs after the ﬁrst process loaded

the item, and then we have to mark as read a deleted object.

This and other issues led to the idea that using stateless functions is a better programming paradigm.

Another way to say the same thing is to suggest using functions and procedures with as few implicit contexts and side-

effects as possible. A function’s implicit context is made up of any of the global variables or items in the persistence

layer that are accessed from within the function. Side-effects are the changes that a function makes to its implicit

context. If a function saves or deletes data in a global variable or in the persistence layer, it is said to have a side-effect.

Carefully isolating functions with context and side-effects from functions with logic (called pure functions) allow the

following beneﬁts:

• Pure functions are deterministic: given a ﬁxed input, the output will always be the same.

• Pure functions are much easier to change or replace if they need to be refactored or optimized.

• Pure functions are easier to test with unit-tests: There is less need for complex context setup and data cleaning

afterwards.

• Pure functions are easier to manipulate, decorate, and pass around.

In summary, pure functions are more efﬁcient building blocks than classes and objects for some architectures because

they have no context or side-effects.

Obviously, object-orientation is useful and even necessary in many cases, for example when developing graphical

desktop applications or games, where the things that are manipulated (windows, buttons, avatars, vehicles) have a

relatively long life of their own in the computer’s memory.

2.1.5 Decorators

The Python language provides a simple yet powerful syntax called ‘decorators’. A decorator is a function or a class that

wraps (or decorates) a function or a method. The ‘decorated’ function or method will replace the original ‘undecorated’

function or method. Because functions are ﬁrst-class objects in Python, this can be done ‘manually’, but using the

@decorator syntax is clearer and thus preferred.

def foo():

# do something

def decorator(func):

# manipulate func

12 Chapter 2. Writing Great Code

Python Guide Documentation, Release 0.0.1

return func

foo = decorator(foo) # Manually decorate

@decorator

def bar():

# Do something

# bar() is decorated

This mechanism is useful for separating concerns and avoiding external un-related logic ‘polluting’ the core logic

of the function or method. A good example of a piece of functionality that is better handled with decoration is

memoization or caching: you want to store the results of an expensive function in a table and use them directly instead

of recomputing them when they have already been computed. This is clearly not part of the function logic.

2.1.6 Dynamic typing

Python is dynamically typed, which means that variables do not have a ﬁxed type. In fact, in Python, variables are

very different from what they are in many other languages, speciﬁcally statically-typed languages. Variables are not a

segment of the computer’s memory where some value is written, they are ‘tags’ or ‘names’ pointing to objects. It is

therefore possible for the variable ‘a’ to be set to the value 1, then to the value ‘a string’, then to a function.

The dynamic typing of Python is often considered to be a weakness, and indeed it can lead to complexities and hard-

to-debug code. Something named ‘a’ can be set to many different things, and the developer or the maintainer needs to

track this name in the code to make sure it has not been set to a completely unrelated object.

Some guidelines help to avoid this issue:

• Avoid using the same variable name for different things.

Bad

a = 1

a = ’a string’

def a():

pass # Do something

Good

count = 1

msg = ’a string’

def func():

pass # Do something

Using short functions or methods helps reduce the risk of using the same name for two unrelated things.

It is better to use different names even for things that are related, when they have a different type:

Bad

items = ’a b c d’ # This is a string...

items = items.split(’ ’) # ...becoming a list

items = set(items) # ...and then a set

There is no efﬁciency gain when reusing names: the assignments will have to create new objects anyway. However,

when the complexity grows and each assignment is separated by other lines of code, including ‘if’ branches and loops,

it becomes harder to ascertain what a given variable’s type is.

Some coding practices, like functional programming, recommend never reassigning a variable. In Java this is done

with the ﬁnal keyword. Python does not have a ﬁnal keyword and it would be against its philosophy anyway. However,

2.1. Structuring Your Project 13

Python Guide Documentation, Release 0.0.1

it may be a good discipline to avoid assigning to a variable more than once, and it helps in grasping the concept of

mutable and immutable types.

2.1.7 Mutable and immutable types

Python has two kinds of built-in or user-deﬁned types.

Mutable types are those that allow in-place modiﬁcation of the content. Typical mutables are lists and dictionaries:

All lists have mutating methods, like list.append() or list.pop(), and can be modiﬁed in place. The same

goes for dictionaries.

Immutable types provide no method for changing their content. For instance, the variable x set to the integer 6 has no

“increment” method. If you want to compute x + 1, you have to create another integer and give it a name.

my_list = [1, 2, 3]

my_list[0] = 4

print my_list # [4, 2, 3] <- The same list as changed

x = 6

x = x + 1 # The new x is another object

One consequence of this difference in behavior is that mutable types are not “stable”, and therefore cannot be used as

dictionary keys.

Using properly mutable types for things that are mutable in nature and immutable types for things that are ﬁxed in

nature helps to clarify the intent of the code.

For example, the immutable equivalent of a list is the tuple, created with (1, 2). This tuple is a pair that cannot be

changed in-place, and can be used as a key for a dictionary.

One peculiarity of Python that can surprise beginners is that strings are immutable. This means that when constructing

a string from its parts, it is much more efﬁcient to accumulate the parts in a list, which is mutable, and then glue (‘join’)

the parts together when the full string is needed. One thing to notice, however, is that list comprehensions are better

and faster than constructing a list in a loop with calls to append().

Bad

# create a concatenated string from 0 to 19 (e.g. "012..1819")

nums = ""

for n in range(20):

nums += str(n) # slow and inefficient

print nums

Good

# create a concatenated string from 0 to 19 (e.g. "012..1819")

nums = []

for n in range(20):

nums.append(str(n))

print "".join(nums) # much more efficient

Best

# create a concatenated string from 0 to 19 (e.g. "012..1819")

nums = [str(n) for n in range(20)]

print "".join(nums)

One ﬁnal thing to mention about strings is that using join() is not always best. In the instances where you are

creating a new string from a pre-determined number of strings, using the addition operator is actually faster, but in

14 Chapter 2. Writing Great Code

Python Guide Documentation, Release 0.0.1

Bad

def make_complex(

args):

x, y = args

return dict(

locals())

Good

def make_complex(x, y):

return {’x’: x, ’y’: y}

In the good code above, x and y are explicitly received from the caller, and an explicit dictionary is returned. The

developer using this function knows exactly what to do by reading the ﬁrst and last lines, which is not the case with

the bad example.

One statement per line

While some compound statements such as list comprehensions are allowed and appreciated for their brevity and their

expressiveness, it is bad practice to have two disjoint statements on the same line of code.

Bad

print ’one’; print ’two’

if x == 1: print ’one’

if <complex comparison> and <other complex comparison>:

# do something

Good

print ’one’

print ’two’

if x == 1:

print ’one’

cond1 = <complex comparison>

cond2 = <other complex comparison>

if cond1 and cond2:

# do something

Function arguments

Arguments can be passed to functions in four different ways.

1. Positional arguments are mandatory and have no default values. They are the simplest form of arguments and

they can be used for the few function arguments that are fully part of the function’s meaning and their order is

natural. For instance, in send(message, recipient) or point(x, y) the user of the function has no

difﬁculty remembering that those two functions require two arguments, and in which order.

In those two cases, it is possible to use argument names when calling the functions and, doing so, it is possible to

switch the order of arguments, calling for instance send(recipient=’World’, message=’Hello’) and

point(y=2, x=1) but this reduces readability and is unnecessarily verbose, compared to the more straightforward

calls to send(’Hello’, ’World’) and point(1, 2).

2. Keyword arguments are not mandatory and have default values. They are often used for optional parameters

sent to the function. When a function has more than two or three positional parameters, its signature is more

16 Chapter 2. Writing Great Code

剩余96页未读，继续阅读

TT-CHONG

粉丝: 0
资源: 4

Python编程指南：从入门到精通

Python-Guide-Code:《Python入门指南V4.00》的所有范例程式码

python-guide Kenneth Reitz

导向滤波（guide_filter）的python实现

python 图像去雾

cython: a guide for python pdf

python的specs

有与阿里巴巴的java开发手册类似的Python开发手册吗

python全套学习资料

python热爱者的博客

python新手教程

最新资源