Python入门指南：基础教程+进阶技术与实战练习

需积分: 10 107 浏览量更新于2024-07-19 收藏 1.3MB PDF 举报

《Python书：Python入门、高级进阶与Python练习》是一本由Dave Kuhlman编著的专业Python学习指南，旨在提供全面的Python编程课程。该书分为三个部分：初学者入门、高级主题探讨以及丰富的实践练习。第一部分“开始Python”涵盖了基础入门内容，包括： 1.1 概述及资源：为新学员提供必要的学习资源和课程背景介绍，强调了学习Python的实用性和广泛性。 1.1.1 Python语言环境：介绍了如何获取和安装Python环境，以便于读者进行实际操作。 1.1.2 Python概述：对Python语言的特点和用途进行了详细介绍，帮助读者理解为何选择Python作为学习语言。 1.1.3 交互式Python：展示了Python的交互式特性，让学习者在交互环境中逐步熟悉语法和概念。 1.2 语法基础：详细讲解了Python的文本结构，如行、注释、变量名、代码块和缩进规则，这些都是理解和编写有效Python程序的基础。 1.2.4 代码块和缩进：Python的块级结构和严格的缩进来体现其简洁的风格，对代码的清晰度至关重要。 1.2.5 Docstrings：解释了如何使用docstrings（文档字符串），这是一种用于编写函数和类文档的标准方式，有助于提高代码可读性。 1.2.6 程序结构：讲解了Python中的控制流语句（如if-else、循环）和函数，以及模块和包的使用，以构建更复杂的程序。 1.2.7 运算符：涵盖了Python的各种基本运算符，包括算术、比较和逻辑运算符，这对于执行计算和逻辑操作至关重要。 1.2.8 参考资料：提供了进一步探索Python语言和相关工具的链接，鼓励读者深入学习。第二部分是关于高级主题的讨论，可能涉及更复杂的数据结构、面向对象编程、网络编程、并发编程等，为已经掌握基础的读者提供进阶知识。第三部分是Python工作簿，包含大量习题和实践项目，旨在通过实际操作巩固理论知识，提升编程技能。整体来看，《Python Book》是一本全面且深入的教程，适合不同层次的学习者从入门到提升，无论是为了职业发展还是个人兴趣，都是学习Python编程的理想资源。

A Python Book

following line a continuation of the current line. But, note that an opening

"context" (parenthesis, square bracket, or curly bracket) makes the back-slash

unnecessary.

1.2.2 Comments

Everything after "#" on a line is ignored. No block comments, but doc strings are a

comment in quotes at the beginning of a module, class, method or function. Also, editors

with support for Python often provide the ability to comment out selected blocks of code,

usually with "##".

1.2.3 Names and tokens

● Allowed characters: a-z A-Z 0-9 underscore, and must begin with a letter or

underscore.

● Names and identifiers are case sensitive.

● Identifiers can be of unlimited length.

● Special names, customizing, etc. -- Usually begin and end in double underscores.

● Special name classes -- Single and double underscores.

○ Single leading single underscore -- Suggests a "private" method or variable

name. Not imported by "from module import *".

○ Single trailing underscore -- Use it to avoid conflicts with Python keywords.

○ Double leading underscores -- Used in a class definition to cause name

mangling (weak hiding). But, not often used.

● Naming conventions -- Not rigid, but:

○ Modules and packages -- all lower case.

○ Globals and constants -- Upper case.

○ Classes -- Bumpy caps with initial upper.

○ Methods and functions -- All lower case with words separated by underscores.

○ Local variables -- Lower case (with underscore between words) or bumpy

caps with initial lower or your choice.

○ Good advice -- Follow the conventions used in the code on which you are

working.

● Names/variables in Python do not have a type. Values have types.

1.2.4 Blocks and indentation

Python represents block structure and nested block structure with indentation, not with

begin and end brackets.

The empty block -- Use the pass no-op statement.

Benefits of the use of indentation to indicate structure:

Page 16

A Python Book

● Reduces the need for a coding standard. Only need to specify that indentation is 4

spaces and no hard tabs.

● Reduces inconsistency. Code from different sources follow the same indentation

style. It has to.

● Reduces work. Only need to get the indentation correct, not both indentation and

brackets.

● Reduces clutter. Eliminates all the curly brackets.

● If it looks correct, it is correct. Indentation cannot fool the reader.

Editor considerations -- The standard is 4 spaces (no hard tabs) for each indentation level.

You will need a text editor that helps you respect that.

1.2.5 Doc strings

Doc strings are like comments, but they are carried with executing code. Doc strings can

be viewed with several tools, e.g. help(), obj.__doc__, and, in IPython, a question

mark (?) after a name will produce help.

A doc string is written as a quoted string that is at the top of a module or the first lines

after the header line of a function or class.

We can use triple-quoting to create doc strings that span multiple lines.

There are also tools that extract and format doc strings, for example:

● pydoc -- Documentation generator and online help system --

http://docs.python.org/lib/module-pydoc.html.

● epydoc -- Epydoc: Automatic API Documentation Generation for Python --

http://epydoc.sourceforge.net/index.html

● Sphinx -- Can also extract documentation from Python doc strings. See

http://sphinx-doc.org/index.html.

See the following for suggestions and more information on doc strings: Docstring

conventions -- http://www.python.org/dev/peps/pep-0257/.

1.2.6 Program structure

● Execution -- def, class, etc are executable statements that add something to the

current name-space. Modules can be both executable and import-able.

● Statements, data structures, functions, classes, modules, packages.

● Functions

● Classes

● Modules correspond to files with a "*.py" extension. Packages correspond to a

directory (or folder) in the file system; a package contains a file named

"__init__.py". Both modules and packages can be imported (see section import

Page 17

A Python Book

statement).

● Packages -- A directory containing a file named "__init__.py". Can provide

additional initialization when the package or a module in it is loaded (imported).

1.2.7 Operators

● See: http://docs.python.org/ref/operators.html. Python defines the following

operators:

+ - * ** / // %

<< >> & | ^ ~

< > <= >= == != <>

The comparison operators <> and != are alternate spellings of the same operator.

!= is the preferred spelling; <> is obsolescent.

● Logical operators:

and or is not in

● There are also (1) the dot operator, (2) the subscript operator [], and the

function/method call operator ().

● For information on the precedences of operators, see the table at

http://docs.python.org/2/reference/expressions.html#operator-precedence, which

is reproduced below.

● For information on what the different operators do, the section in the "Python

Language Reference" titled "Special method names" may be of help:

http://docs.python.org/2/reference/datamodel.html#special-method-names

The following table summarizes the operator precedences in Python, from lowest

precedence (least binding) to highest precedence (most binding). Operators on the

same line have the same precedence. Unless the syntax is explicitly given,

operators are binary. Operators on the same line group left to right (except for

comparisons, including tests, which all have the same precedence and chain from

left to right -- see section 5.9 -- and exponentiation, which groups from right to

left):

Operator Description

======================== ==================

lambda Lambda expression

or Boolean OR

and Boolean AND

not x Boolean NOT

in, not in Membership tests

is, is not Identity tests

<, <=, >, >=, <>, !=, == Comparisons

| Bitwise OR

^ Bitwise XOR

& Bitwise AND

<<, >> Shifts

Page 18

A Python Book

+, - Addition and subtraction

*, /, % Multiplication, division,

remainder

+x, -x Positive, negative

~x Bitwise not

** Exponentiation

x.attribute Attribute reference

x[index] Subscription

x[index:index] Slicing

f(arguments...) Function call

(expressions...) Binding or tuple display

[expressions...] List display

{key:datum...} Dictionary display

`expressions...` String conversion

● Note that most operators result in calls to methods with special names, for

example __add__, __sub__, __mul__, etc. See Special method names

http://docs.python.org/2/reference/datamodel.html#special-method-names

Later, we will see how these operators can be emulated in classes that you define

yourself, through the use of these special names.

1.2.8 Also see

For more on lexical matters and Python styles, see:

● Code Like a Pythonista: Idiomatic Python --

http://python.net/~goodger/projects/pycon/2007/idiomatic/handout.html.

● Style Guide for Python Code -- http://www.python.org/dev/peps/pep-0008/

● The flake8 style checking program. See https://pypi.python.org/pypi/flake8. Also

see the pylint code checker: https://pypi.python.org/pypi/pylint.

1.2.9 Code evaluation

Understanding the Python execution model -- How Python evaluates and executes your

code.

Evaluating expressions.

Creating names/variables -- Binding -- The following all create names (variables) and

bind values (objects) to them: (1) assignment, (2) function definition, (3) class definition,

(4) function and method call, (5) importing a module, ...

First class objects -- Almost all objects in Python are first class. Definition: An object is

first class if: (1) we can put it in a structured object; (2) we can pass it to a function; (3)

we can return it from a function.

References -- Objects (or references to them) can be shared. What does this mean?

● The object(s) satisfy the identity test operator is.

Page 19

剩余277页未读，继续阅读

ablimet

粉丝: 2
资源: 16

Python入门指南：基础教程+进阶技术与实战练习

学习Python编程：从入门到高级实战

"Full Speed Python: 快速入门Python3下载和安装教程

麻省理工Python教程：入门计算机科学

python-exercises::nerd_face: 学习Python系列练习

python-exercises:python练习

python-exercises:Python练习

python-exercises：python学校练习

python-exercises:Codeup Python练习

Python-Exercises:Python编码实践练习

Python_Exercises：一些python练习示例

最新资源