Python 3学习指南：思维像计算机科学家的编程入门

需积分: 10 112 浏览量更新于2024-07-18 收藏 2.32MB PDF 举报

《如何像计算机科学家一样思考：使用Python 3学习》是一本详细的编程指南，由Peter Wentworth、Jeffrey Elkner、Allen B. Downey和Chris Meyers共同编写，适用于Python 3.x版本。该文档于2018年4月30日发布，旨在帮助读者掌握计算机科学的基本思维方式，并通过Python语言实践。这本书的核心内容分为多个部分： 1. **程序思维方式**（Chapter 1）：介绍了计算机科学的基础理念，引导读者理解程序设计的本质，包括解决问题的逻辑结构和步骤。 2. **变量、表达式与语句**（Chapter 2）：讲解了如何在Python中声明和操作变量，以及如何构建基本的算术和逻辑表达式，同时阐述了语句的作用，如条件语句和循环。 3. **程序流程控制**（Chapter 3）：深入探讨了程序的执行顺序，包括流程控制结构如条件分支（if-else）、循环（for和while）等，以及函数的调用和返回。 4. **函数**（Chapter 4）：解释了函数的概念，如何定义、传递参数和返回值，以及函数在模块化编程中的重要性。 5. **数据类型**（Chapter 5）：介绍了Python中的基本数据类型，如整型、浮点型、字符串、列表、元组、字典等，以及它们的特性和操作方法。 6. **NumPy**（Chapter 6）：扩展到数值计算库NumPy，讲解数组和矩阵操作，以及高级数学函数的使用，这对于科学计算和数据分析至关重要。 7. **文件处理**（Chapter 7）：涵盖了文件的打开、读写操作，以及异常处理，确保数据的输入输出和存储安全。 8. **模块**（Chapter 8）：讨论了如何组织代码，引入外部模块的功能，以及如何创建和导入自定义模块。 9. **更多数据类型**（Chapter 9）：继续介绍更复杂的数据结构，如集合、字节码和生成器，以及它们在实际编程中的应用。 10. **递归**（Chapter 10）：讲解递归算法及其在问题解决中的应用，培养逻辑思维和解决问题的递归能力。 11. **类和对象**（Chapter 11）：进入面向对象编程领域，介绍了类的定义、继承、封装和多态性，以及如何创建和使用对象。 12. **异常处理**（Chapter 12）：探讨错误处理和异常处理机制，如何编写健壮的代码以应对运行时错误。 13. **数据拟合**（Chapter 13）：涉及统计学和机器学习中的数据拟合概念，使用Python进行数据分析和模型建立。 14. **PyGame**（Chapter 14）：介绍了游戏开发框架PyGame，如何利用Python进行图形用户界面和游戏编程。 15. **版权信息**：包含了版权声明，确保作品的合法使用和尊重作者权益。 16. **贡献者列表**：列出本书编者的名单，以及其他对本书有所贡献的人。每一章都配有详细的解释和实例，使得读者能够逐步掌握计算机科学思维和Python编程技术。这本书不仅适合初学者系统学习，也适合有一定基础的开发者查阅和深化理解。

How to Think Like a Computer Scientist: Learning with Python 3 Documentation, Release 3rd

Edition

>>> type('This is a string.')

>>> type("And so is this.")

>>> type("""and this.""")

>>> type('''and even this...''')

Double quoted strings can contain single quotes inside them, as in "Bruce's beard", and single quoted strings

can have double quotes inside them, as in 'The knights who say "Ni!"'.

Strings enclosed with three occurrences of either quote symbol are called triple quoted strings. They can contain either

single or double quotes:

>>> print('''"Oh no", she exclaimed, "Ben's bike is broken!"''')

"Oh no", she exclaimed, "Ben's bike is broken!"

>>>

Triple quoted strings can even span multiple lines:

>>> message = """This message will

... span several

... lines."""

>>> print(message)

This message will

span several

lines.

>>>

Python doesn’t care whether you use single or double quotes or the three-of-a-kind quotes to surround your strings:

once it has parsed the text of your program or command, the way it stores the value is identical in all cases, and the

surrounding quotes are not part of the value. But when the interpreter wants to display a string, it has to decide which

quotes to use to make it look like a string.

>>> 'This is a string.'

'This is a string.'

>>> """And so is this."""

'And so is this.'

So the Python language designers usually chose to surround their strings by single quotes. What do think would

happen if the string already contained single quotes?

When you type a large integer, you might be tempted to use commas between groups of three digits, as in 42,000.

The same goes for entering Dutch-style ﬂoating point numbers using a comma instead of a decimal dot. This is not a

legal integer in Python, but it does mean something else, which is legal:

>>> 42000

42000

>>> 42,000

(42, 0)

Well, that’s not what we expected at all! Because of the comma, Python chose to treat this as a pair of values. We’ll

come back to learn about pairs later. But, for the moment, remember not to put commas or spaces in your integers, no

matter how big they are. Also revisit what we said in the previous chapter: formal languages are strict, the notation is

concise, and even the smallest change might mean something quite different from what you intended.

12 Chapter 2. Variables, expressions and statements

How to Think Like a Computer Scientist: Learning with Python 3 Documentation, Release 3rd

Edition

2.2 Variables

One of the most powerful features of a programming language is the ability to manipulate variables. A variable is a

name that refers to a value.

The assignment statement gives a value to a variable:

>>> message = "What's up, Doc?"

>>> n = 17

>>> pi = 3.14159

This example makes three assignments. The ﬁrst assigns the string value "What's up, Doc?" to a variable

named message. The second gives the integer 17 to n, and the third assigns the ﬂoating-point number 3.14159 to

a variable called pi.

The assignment token, =, should not be confused with equals, which uses the token ==. The assignment statement

binds a name, on the left-hand side of the operator, to a value, on the right-hand side. Basically, an assignment is an

order, and the equals operator can be read as a question mark. This is why you will get an error if you enter:

>>> 17 = n

File "<interactive input>", line 1

SyntaxError: can't assign to literal

Tip: When reading or writing code, say to yourself “n is assigned 17” or “n gets the value 17”. Don’t

say “n equals 17”.

A common way to represent variables on paper is to write the name with an arrow pointing to the variable’s value.

This kind of ﬁgure is called a state snapshot because it shows what state each of the variables is in at a particular

instant in time. (Think of it as the variable’s state of mind). Some editors and programming environments do this for

you, and allow you to click through the state of the program saving you some paper. This diagram shows the result of

executing the assignment statements:

If you ask the interpreter to evaluate a variable, it will produce the value that is currently linked to the variable:

>>> message

'What's up, Doc?'

>>> n

>>> pi

3.14159

We use variables in a program to “remember” things, perhaps the current score at the football game. But variables are

variable. This means they can change over time, just like the scoreboard at a football game. You can assign a value to

a variable, and later assign a different value to the same variable. (This is different from maths. In maths, if you give

‘x‘ the value 3, it cannot change to link to a different value half-way through your calculations!)

>>> day = "Thursday"

>>> day

'Thursday'

>>> day = "Friday"

2.2. Variables 13

How to Think Like a Computer Scientist: Learning with Python 3 Documentation, Release 3rd

Edition

>>> day

'Friday'

>>> day = 21

>>> day

You’ll notice we changed the value of day three times, and on the third assignment we even made it refer to a value

that was of a different type.

A great deal of programming is about having the computer remember things, e.g. The number of missed calls on your

phone, and then arranging to update or change the variable when you miss another call.

2.3 Variable names and keywords

Variable names can be arbitrarily long. They can contain both letters and digits, but they have to begin with a letter

or an underscore. Although it is legal to use uppercase letters, by convention we don’t. If you do, remember that case

matters. Bruce and bruce are different variables.

The underscore character ( _) can appear in a name. It is often used in names with multiple words, such as my_name

or price_of_tea_in_china.

There are some situations in which names beginning with an underscore have special meaning, so a safe rule for

beginners is to start all names with a letter.

If you give a variable an illegal name, you get a syntax error:

>>> 76trombones = "big parade"

SyntaxError: invalid syntax

>>> more$ = 1000000

SyntaxError: invalid syntax

>>> class = "Computer Science 101"

SyntaxError: invalid syntax

76trombones is illegal because it does not begin with a letter. more$ is illegal because it contains an illegal

character, the dollar sign. But what’s wrong with class?

It turns out that class is one of the Python keywords. Keywords deﬁne the language’s syntax rules and structure,

and they cannot be used as variable names.

Python has thirty-something keywords (and every now and again improvements to Python introduce or eliminate one

or two):

and as assert break class continue

def del elif else except exec

ﬁnally for from global if import

in is lambda nonlocal not or

pass raise return try while with

yield True False None

You might want to keep this list handy. If the interpreter complains about one of your variable names and you don’t

know why, see if it is on this list.

Programmers generally choose names for their variables that are meaningful to the human readers of the program —

they help the programmer document, or remember, what the variable is used for.

14 Chapter 2. Variables, expressions and statements

How to Think Like a Computer Scientist: Learning with Python 3 Documentation, Release 3rd

Edition

Caution: Beginners sometimes confuse “meaningful to the human readers” with “meaningful to the computer”.

So they’ll wrongly think that because they’ve called some variable average or pi, it will somehow magically

calculate an average, or magically know that the variable pi should have a value like 3.14159. No! The computer

doesn’t understand what you intend the variable to mean.

So you’ll ﬁnd some instructors who deliberately don’t choose meaningful names when they teach beginners —

not because we don’t think it is a good habit, but because we’re trying to reinforce the message that you — the

programmer — must write the program code to calculate the average, and you must write an assignment statement

to give the variable pi the value you want it to have.

e = 3.1415

ray = 10

size = e

ray

pi = 3.1415

radius = 10

area = pi

radius

The above two snippets do exactly the same thing, but the bottom one uses the right kind of variable names. For the

computer there is no difference at all, but for a human, using the names and letters that are part of the conventional

way of writing things make all the difference in the world. Using e instead of pi completely confuses people,

while computers will just perform the calculation!

2.4 Statements

A statement is an instruction that the Python interpreter can execute. We have only seen the assignment statement so

far. Some other kinds of statements that we’ll see shortly are while statements, for statements, if statements, and

import statements. (There are other kinds too!)

When you type a statement on the command line, Python executes it. Statements don’t produce any result.

2.5 Evaluating expressions

An expression is a combination of values, variables, operators, and calls to functions. If you type an expression at the

Python prompt, the interpreter evaluates it and displays the result:

>>> 1 + 1

>>> len("hello")

In this example len is a built-in Python function that returns the number of characters in a string. We’ve previously

seen the print and the type functions, so this is our third example of a function!

The evaluation of an expression produces a value, which is why expressions can appear on the right hand side of

assignment statements. A value all by itself is a simple expression, and so is a variable.

>>> 17

>>> y = 3.14

>>> x = len("hello")

>>> x

2.4. Statements 15

剩余362页未读，继续阅读

qiaoyafeng

粉丝: 0

Python 3学习指南：思维像计算机科学家的编程入门

How to Think Like a Computer Scientist - Learning with Python 3 documentation

How to Think Like a Computer Scientist: Learning with Python 3

Think Python-How to Think Like a Computer Scientist翻译版

How_To_Think_Like_A_Computer_Scientist-Learning_With_Python

How_To_Think_Like_A_Computer_Scientist-Learning_With_Python-2002 [miex.org].pdf

How to think like a computer scientist -- learning with Python

Think Like a Computer Scientist--Learning with Python

How to Think Like a Computer Scientist-Learning with Python

How to Think Like a Computer Scientist- Learning with Python 3 黄

think-like-a-computer-scientist-python-replit-book

最新资源