Python编程入门教程：官方指南

需积分: 10 147 浏览量更新于2024-07-15 收藏 772KB PDF 举报

"Python教程，由官方制作，全英文，PDF格式，内容涵盖Python的基础到进阶，适合初学者和有经验的开发者学习。" 在Python官方教程中，它提供了全面的指导来帮助用户理解并使用Python语言。以下是教程中涵盖的一些关键知识点： 1. **Whetting Your Appetite**（引发兴趣）：这部分可能是一些吸引人的例子或概述，展示Python的易用性和功能，以激发读者对Python的兴趣。 2. **Using the Python Interpreter**（使用Python解释器）： - **Invoking the Interpreter**（调用解释器）：讲解如何启动Python解释器，无论是通过命令行还是集成开发环境（IDE）。 - **The Interpreter and Its Environment**（解释器及其环境）：介绍解释器的工作原理、如何设置环境变量以及如何查看Python版本等。 3. **An Informal Introduction to Python**（非正式的Python介绍）： - **Using Python as a Calculator**（将Python作为计算器使用）：教授基础的数学运算，如加减乘除，以及使用括号控制运算顺序。 - **First Steps Towards Programming**（编程的初步步骤）：介绍变量的使用、数据类型、赋值语句以及简单的输入/输出操作。 4. **More Control Flow Tools**（更多的控制流程工具）： - **if Statements**（if语句）：讲解条件语句，包括if、elif和else。 - **for Statements**（for循环）：介绍如何遍历序列，如列表和字符串。 - **The range() Function**（range函数）：提供一个用于循环的数字序列，常用于for循环。 - **break and continue Statements, and else Clauses on Loops**（break、continue语句和循环的else子句）：解释如何在循环中中断或跳过迭代，以及else子句的作用。 - **pass Statements**（pass语句）：作为占位符，不做任何操作。 - **Defining Functions**（定义函数）：教授如何创建自定义函数，包括参数和返回值。 5. **Data Structures**（数据结构）： - **More on Lists**（关于列表的更多内容）：深入讨论列表的创建、修改、切片和操作方法。 - **The del statement**（del语句）：用于删除列表元素或整个列表。 - **Tuples and Sequences**（元组和序列）：介绍不可变序列元组，以及它们与列表的区别。 - **Sets**（集合）：讲解无序、不重复元素的集合数据类型。 - **Dictionaries**（字典）：介绍键值对的数据结构，以及如何访问、修改和操作字典。 - **Looping Techniques**（循环技巧）：包含for-in循环、while循环以及各种遍历数据结构的方法。 - **More on Conditions**（关于条件的更多内容）：深入讨论比较和逻辑运算符。 6. **Modules**（模块）： - **More on Modules**（关于模块的更多内容）：解释如何导入和使用模块，以及模块的重载和更新。 - **Standard Modules**（标准库模块）：列出Python自带的模块，如os、sys、math等。 - **The dir() Function**（dir()函数）：用于获取对象属性和方法的列表。 - **Packages**（包）：介绍如何组织模块成包，实现模块的分层结构。 7. **Input and Output**（输入与输出）： - **Fancier Output Formatting**（更复杂的输出格式化）：涉及如何格式化输出，包括字符串模板、制表符和换行符的使用。这些章节覆盖了Python编程的基础，包括语法、控制流、数据结构、模块化和I/O操作，是学习Python编程的宝贵资源。

Python Tutorial, Release 3.8.4rc1

Division (/) always returns a ﬂoat. To do ﬂoor division and get an integer result (discarding any fractional result) you can

use the // operator; to calculate the remainder you can use %:

>>> 17 / 3 # classic division returns a float

5.666666666666667

>>>

>>> 17 // 3 # floor division discards the fractional part

>>> 17 % 3 # the % operator returns the remainder of the division

>>> 5 * 3 + 2 # result * divisor + remainder

With Python, it is possible to use the ** operator to calculate powers

>>> 5 ** 2 # 5 squared

>>> 2 ** 7 # 2 to the power of 7

128

The equal sign (=) is used to assign a value to a variable. Afterwards, no result is displayed before the next interactive

prompt:

>>> width = 20

>>> height = 5 * 9

>>> width * height

900

If a variable is not “deﬁned” (assigned a value), trying to use it will give you an error:

>>> n # try to access an undefined variable

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

NameError: name 'n' is not defined

There is full support for ﬂoating point; operators with mixed type operands convert the integer operand to ﬂoating point:

>>> 4 * 3.75 - 1

14.0

In interactive mode, the last printed expression is assigned to the variable _. This means that when you are using Python

as a desk calculator, it is somewhat easier to continue calculations, for example:

>>> tax = 12.5 / 100

>>> price = 100.50

>>> price * tax

12.5625

>>> price + _

113.0625

>>> round(_, 2)

113.06

This variable should be treated as read-only by the user. Don’t explicitly assign a value to it — you would create an

independent local variable with the same name masking the built-in variable with its magic behavior.

Since ** has higher precedence than -, -3**2 will be interpreted as -(3**2) and thus result in -9. To avoid this and get 9, you can use

(-3)**2.

10 Chapter 3. An Informal Introduction to Python

Python Tutorial, Release 3.8.4rc1

In addition to int and float, Python supports other types of numbers, such as Decimal and Fraction. Python

also has built-in support for complex numbers, and uses the j or J suﬃx to indicate the imaginary part (e.g. 3+5j).

3.1.2 Strings

Besides numbers, Python can also manipulate strings, which can be expressed in several ways. They can be enclosed in

single quotes ('...') or double quotes ("...") with the same result

. \ can be used to escape quotes:

>>> 'spam eggs' # single quotes

'spam eggs'

>>> 'doesn\'t' # use \' to escape the single quote...

"doesn't"

>>> "doesn't" # ...or use double quotes instead

"doesn't"

>>> '"Yes," they said.'

'"Yes," they said.'

>>> "\"Yes,\" they said."

'"Yes," they said.'

>>> '"Isn\'t," they said.'

'"Isn\'t," they said.'

In the interactive interpreter, the output string is enclosed in quotes and special characters are escaped with backslashes.

While this might sometimes look diﬀerent from the input (the enclosing quotes could change), the two strings are equiv-

alent. The string is enclosed in double quotes if the string contains a single quote and no double quotes, otherwise it is

enclosed in single quotes. The print() function produces a more readable output, by omitting the enclosing quotes

and by printing escaped and special characters:

>>> '"Isn\'t," they said.'

'"Isn\'t," they said.'

>>> print('"Isn\'t," they said.')

"Isn't," they said.

>>> s = 'First line.\nSecond line.' # \n means newline

>>> s # without print(), \n is included in the output

'First line.\nSecond line.'

>>> print(s) # with print(), \n produces a new line

First line.

Second line.

If you don’t want characters prefaced by \ to be interpreted as special characters, you can use raw strings by adding an r

before the ﬁrst quote:

>>> print('C:\some\name') # here \n means newline!

C:\some

ame

>>> print(r'C:\some\name') # note the r before the quote

C:\some\name

String literals can span multiple lines. One way is using triple-quotes: """...""" or '''...'''. End of lines are

automatically included in the string, but it’s possible to prevent this by adding a \ at the end of the line. The following

example:

print("""\

Usage: thingy [OPTIONS]

(continues on next page)

Unlike other languages, special characters such as \n have the same meaning with both single ('...') and double ("...") quotes. The only

diﬀerence between the two is that within single quotes you don’t need to escape " (but you have to escape \') and vice versa.

3.1. Using Python as a Calculator 11

Python Tutorial, Release 3.8.4rc1

>>> word[-1] # last character

'n'

>>> word[-2] # second-last character

'o'

>>> word[-6]

'P'

Note that since -0 is the same as 0, negative indices start from -1.

In addition to indexing, slicing is also supported. While indexing is used to obtain individual characters, slicing allows you

to obtain substring:

>>> word[0:2] # characters from position 0 (included) to 2 (excluded)

'Py'

>>> word[2:5] # characters from position 2 (included) to 5 (excluded)

'tho'

Note how the start is always included, and the end always excluded. This makes sure that s[:i] + s[i:] is always

equal to s:

>>> word[:2] + word[2:]

'Python'

>>> word[:4] + word[4:]

'Python'

Slice indices have useful defaults; an omitted ﬁrst index defaults to zero, an omitted second index defaults to the size of

the string being sliced.

>>> word[:2] # character from the beginning to position 2 (excluded)

'Py'

>>> word[4:] # characters from position 4 (included) to the end

'on'

>>> word[-2:] # characters from the second-last (included) to the end

'on'

One way to remember how slices work is to think of the indices as pointing between characters, with the left edge of the

ﬁrst character numbered 0. Then the right edge of the last character of a string of n characters has index n, for example:

+---+---+---+---+---+---+

| P | y | t | h | o | n |

+---+---+---+---+---+---+

0 1 2 3 4 5 6

-6 -5 -4 -3 -2 -1

The ﬁrst row of numbers gives the position of the indices 0…6 in the string; the second row gives the corresponding

negative indices. The slice from i to j consists of all characters between the edges labeled i and j, respectively.

For non-negative indices, the length of a slice is the diﬀerence of the indices, if both are within bounds. For example, the

length of word[1:3] is 2.

Attempting to use an index that is too large will result in an error:

>>> word[42] # the word only has 6 characters

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

IndexError: string index out of range

However, out of range slice indexes are handled gracefully when used for slicing:

3.1. Using Python as a Calculator 13

剩余158页未读，继续阅读

loukangzhi

粉丝: 0
资源: 1

Python编程入门教程：官方指南

vivado -sysgen tutorial

operating_system_tutorial.pdf

Verdi User Guide and Tutorial.pdf

vulkan tutorial.pdf

ug871-vivado-high-level-synthesis-tutorial.pdf

verdi user guide and tutorial.pdf

请给我一份ISE的官方文档

selenium 入门资料

zynq DDR/SD/Ethernet/USB/Uart/AD9516/SFP的脚本测试例程

c语言程序设计校园导航系统,C语言校园导航系统.pdf

最新资源