Python官方快速入门教程：2小时掌握基础

需积分: 10 121 浏览量更新于2024-07-22 2 收藏 1.11MB PDF 举报

本资源是一份Python官方的快速教程，由Guido van Rossum编写，适合编程新手快速入门。教程发布于2014年2月19日，由Python Software Foundation提供。该教程旨在用短短两个小时的时间帮助学习者理解Python的基础概念，并通过实践掌握核心语法。第1章"Whetting Your Appetite" 引入了Python的魅力，让读者对语言有所期待，激发学习兴趣。随后的章节逐步展开：第2章"Using the Python Interpreter" 部分讲解如何启动Python解释器，以及交互式环境的使用。这部分涵盖了命令行输入、环境变量和基本交互操作。第3章"An Informal Introduction to Python" 介绍了Python作为计算器的功能，演示了如何进行基本算术运算，并引导读者步入编程第一步。这里强调了基础算术和简单逻辑控制的运用。第4章"More Control Flow Tools" 集中于控制流程，包括条件语句（if-elif-else）、循环结构（for和while）、range函数、break和continue语句，以及如何定义和使用函数。同时，还讨论了编码风格的重要性，以便养成良好的编程习惯。第5章"Data Structures" 深入讲解Python的数据结构，如列表（及其更多操作）、元组、集合、字典以及循环和条件语句在处理这些数据结构中的应用。这一部分是理解和操作Python的关键。第6章"Modules" 介绍模块的概念，包括如何导入模块、标准库模块的使用，以及dir()函数的用法。此外，还涉及到了Python包的组织和管理。第7章"Input and Output" 讲解如何处理用户输入和输出，如何实现更复杂的数据格式化，为实际项目中的数据处理打下基础。这份教程的每个章节都设计得易于理解，旨在让初学者在短时间内掌握Python的基础知识，为后续深入学习和实践奠定坚实基础。无论是希望快速上手编程的新手，还是希望回顾基础知识的开发者，这份教程都是一个理想的起点。

Python Tutorial, Release 3.3.4

>>>

>>> 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

>>> 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:

>>> 3

3.75 / 1.5

7.5

>>> 7.0 / 2

3.5

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.

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 sufﬁx to indicate the imaginary part

(e.g. 3+5j).

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)

10 Chapter 3. An Informal Introduction to Python

Python Tutorial, Release 3.3.4

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," he said.’

’"Yes," he said.’

>>> "\"Yes,\" he said."

’"Yes," he said.’

>>> ’"Isn\’t," she said.’

’"Isn\’t," she said.’

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

slashes. While this might sometimes look different from the input (the enclosing quotes could change), the two

strings are equivalent. 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," she said.’

’"Isn\’t," she said.’

>>> print(’"Isn\’t," she said.’)

"Isn’t," she 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]

-h Display this usage message

-H hostname Hostname to connect to

""")

produces the following output (note that the initial newline is not included):

Usage: thingy [OPTIONS]

-h Display this usage message

-H hostname Hostname to connect to

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

The only difference 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.3.4

>>> 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 difference of the indices, if both are within bounds. For

example, the length of word[1:3] is 2.

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

>>> word[42] # the word only has 7 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:

>>> word[4:42]

’on’

>>> word[42:]

’’

Python strings cannot be changed — they are immutable. Therefore, assigning to an indexed position in the string

results in an error:

>>> word[0] = ’J’

...

TypeError: ’str’ object does not support item assignment

>>> word[2:] = ’py’

...

TypeError: ’str’ object does not support item assignment

If you need a different string, you should create a new one:

>>> ’J’ + word[1:]

’Jython’

>>> word[:2] + ’py’

’Pypy’

The built-in function len() returns the length of a string:

>>> s = ’supercalifragilisticexpialidocious’

>>> len(s)

See also:

3.1. Using Python as a Calculator 13

Python Tutorial, Release 3.3.4

textseq Strings are examples of sequence types, and support the common operations supported by such types.

string-methods Strings support a large number of methods for basic transformations and searching.

string-formatting Information about string formatting with str.format() is described here.

old-string-formatting The old formatting operations invoked when strings and Unicode strings are the left

operand of the % operator are described in more detail here.

3.1.3 Lists

Python knows a number of compound data types, used to group together other values. The most versatile is the

list, which can be written as a list of comma-separated values (items) between square brackets. Lists might contain

items of different types, but usually the items all have the same type.

>>> squares = [1, 2, 4, 9, 16, 25]

>>> squares

[1, 2, 4, 9, 16, 25]

Like strings (and all other built-in sequence type), lists can be indexed and sliced:

>>> squares[0] # indexing returns the item

>>> squares[-1]

>>> squares[-3:] # slicing returns a new list

[9, 16, 25]

All slice operations return a new list containing the requested elements. This means that the following slice returns

a new (shallow) copy of the list:

>>> squares[:]

[1, 2, 4, 9, 16, 25]

Lists also supports operations like concatenation:

>>> squares + [36, 49, 64, 81, 100]

[1, 2, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Unlike strings, which are immutable, lists are a mutable type, i.e. it is possible to change their content:

>>> cubes = [1, 8, 27, 65, 125] # something’s wrong here

>>> 4

3 # the cube of 4 is 64, not 65!

>>> cubes[3] = 64 # replace the wrong value

>>> cubes

[1, 8, 27, 64, 125]

You can also add new items at the end of the list, by using the append() method (we will see more about

methods later):

>>> cubes.append(216) # add the cube of 6

>>> cubes.append(7

3) # and the cube of 7

>>> cubes

[1, 8, 27, 64, 125, 216, 343]

Assignment to slices is also possible, and this can even change the size of the list or clear it entirely:

>>> letters = [’a’, ’b’, ’c’, ’d’, ’e’, ’f’, ’g’]

>>> letters

[’a’, ’b’, ’c’, ’d’, ’e’, ’f’, ’g’]

>>> # replace some values

>>> letters[2:5] = [’C’, ’D’, ’E’]

>>> letters

[’a’, ’b’, ’C’, ’D’, ’E’, ’f’, ’g’]

14 Chapter 3. An Informal Introduction to Python

剩余126页未读，继续阅读

peacepassion

粉丝: 11
资源: 3

Python官方快速入门教程：2小时掌握基础

PYTHON官方文档

官方python3教程

python教程

python快速入门教程

python系列基础教程

python系列视频教程

推荐Python入门教程

python3基础教程

python游戏开发教程

python3基础教程 pdf

最新资源