使用Python解决算法问题：编程和算法思维入门

需积分: 9 137 浏览量更新于2024-07-16 收藏 1.96MB PDF 举报

用Python解决算法问题（John B. Schneider）本书使用Python向人们介绍编程和算法思维，侧重于经典算法，但也对基本的算法问题解决技术有深入的了解。本书的主要内容包括Python基础知识、算法问题解决技术、数据结构和算法设计等方面。 1. 算法思维和编程基础算法思维是解决问题的核心，编程是实现算法的工具。Python是一种流行的编程语言，易于学习和使用。编程基础知识包括变量、数据类型、运算符、控制结构、函数等。了解这些基础知识是学习算法思维的前提。 2. Python基础知识 Python是一种高级语言，具有简洁高效的特点。Python基础知识包括字面量、类型、表达式、语句、赋值运算符、多行语句和多行字符串等。了解这些基础知识是学习Python的前提。 3. 算法问题解决技术算法问题解决技术是本书的核心内容。包括经典算法、基本的算法问题解决技术、数据结构和算法设计等方面。这些技术可以帮助读者解决实际问题，提高编程能力和算法思维。 4. 数据结构和算法设计数据结构和算法设计是解决实际问题的关键。包括数组、链表、栈、队列、树、图等数据结构和排序、查找、遍历等算法设计技术。这些技术可以帮助读者解决实际问题，提高编程能力和算法思维。 5. 实践和应用实践和应用是学习算法思维和编程的关键。通过实践和应用，读者可以提高编程能力和算法思维，解决实际问题。本书使用Python向人们介绍编程和算法思维，侧重于经典算法，但也对基本的算法问题解决技术有深入的了解。本书的主要内容包括Python基础知识、算法问题解决技术、数据结构和算法设计等方面，可以帮助读者解决实际问题，提高编程能力和算法思维。知识点： * 算法思维和编程基础 * Python基础知识 * 算法问题解决技术 * 数据结构和算法设计 * 实践和应用详细说明： * 算法思维是解决问题的核心，编程是实现算法的工具。Python是一种流行的编程语言，易于学习和使用。 * Python基础知识包括字面量、类型、表达式、语句、赋值运算符、多行语句和多行字符串等。 * 算法问题解决技术包括经典算法、基本的算法问题解决技术、数据结构和算法设计等方面。 * 数据结构和算法设计包括数组、链表、栈、队列、树、图等数据结构和排序、查找、遍历等算法设计技术。 * 实践和应用是学习算法思维和编程的关键。

8 CHAPTER 1. INTRODUCTION

ferent Python implementations available. The one that we will use, i.e., the one available from

python.org, is sometimes called CPython and was written in the C programming language.

Other implementations that exist include IronPython (which works with the Microsoft .NET frame-

work), Jython (which was written in Java), and PyPy (which is written in Python). The details of

how these different implementations translate statements from the Python language into some-

thing the computer understands is not our concern. However, it is worthwhile to try to distinguish

between compilers and interpreters.

Some computer languages, such as FORTRAN, C, and C++, typically require that you write

a program, then you compile it (i.e., have a separate program known as a compiler translate your

program into executable code the computer understands), and ﬁnally you run it. The CPython

implementation of Python is different in that we can write statements and have the Python in-

terpreter act on them immediately. In this way we can instantly see what individual statements

do. The instant feedback provided by interpreters, such as CPython, is useful in learning to pro-

gram. An interpreter is a program that is somewhat like a compiler in that it takes statements

that we’ve written in a computer language and translates them into something the computer under-

stands. However, with an interpreter, the translation is followed immediately by execution. Each

statement is executed “on the ﬂy.”

1.6 Running Python

With Python we can use interactive sessions in which we enter statements one at a time and the

interpreter acts on them. Alternatively, we can write all our commands, i.e., our program, in a ﬁle

that is stored on the computer and then have the interpreter act on that stored program. In this

case some compilation may be done behind the scenes, but Python will still not typically provide

speeds comparable to a true compiled language.

We will discuss putting programs in ﬁles in Sec.

1.6.2. First, we want to consider the two most common forms of interactive sessions for the Python

interpreter.

Returning to the statements in Listing 1.3, if they are entered in an interactive session, it is

difﬁcult to observe the behavior that was described for that listing because the print() state-

ments have to be entered one at a time and output will be produced immediately after each entry.

In Python we can have multiple statements on a single line if the statements are separated by a

semicolon. Thus, if you want to verify that the code in Listing 1.3 is correct, you should enter it as

shown in Listing 1.5.

Compiled languages, such as C++ and Java, typically have an advantage in speed over interpreted languages such

as Python. When speed is truly critical in an application, it is unlikely one would want to use Python. However, in

most applications Python is “fast enough.” Furthermore, the time required to develop a program in Python is typically

much less than in other languages. This shorter development time can often more than compensate for the slower

run-time. For example, if it takes one day to write a program in Python but a week to write it in Java, is it worth the

extra development time if the program takes one second to run in Java but two seconds to run in Python? Sometimes

the answer to this is deﬁnitely yes, but this is more the exception rather than the rule. Although it is beyond the scope

of this book, one can create programs that use Python together with code written in C. This approach can be used to

provide execution speeds that exceed the capabilities of programs written purely in Python.

When the CPython interpreter runs commands from a ﬁle for the ﬁrst time, it compiles a “bytecode” version of

the code which is then run by the interpreter. The bytecode is stored in a ﬁle with a .pyc extension. When the ﬁle

code is rerun, the Python interpreter actually uses the bytecode rather than re-interpreting the original code as long as

the Python statements have not been changed. This speeds up execution of the code.

1.6. RUNNING PYTHON 9

Listing 1.5 A Hello-World program similar to Listing 1.3 except that both print() statements

are given on a single line. This form of the program is suitable for entry in an interactive Python

session.

print("Hello", end=" "); print("World!")

1.6.1 Interactive Sessions and Comments

When you install Python, an application called IDLE will be installed on your system. On a Mac,

this is likely to be in the folder /Applications/Python 3.2. On a Windows machine, click

the Start button in the lower left corner of the screen. A window should pop up. If you don’t

see any mention of Python, click All Programs. You will eventually see a large listing of

programs. There should be an entry that says Python 3.2. Clicking Python 3.2 will bring

up another list in which you will see IDLE (Python GUI) (GUI stands for Graphical User

Interface).

IDLE is an integrated development environment (IDE). It is actually a separate program that

stands between us and the interpreter, but it is not very intrusive—the commands we enter are still

sent to the interpreter and we can obtain on-the-ﬂy feedback. After starting IDLE, you should see

(after a bit of boilerplate information) the Python interactive prompt which is three greater-than

signs (>>>). At this point you are free to issue Python commands. Listing 1.6 demonstrates how

the window will appear after the code from Listing 1.1 has been entered. For interactive sessions,

programmer input will be shown in bold Courier font although, as shown in subsequent listings,

comments will be shown in a slanted, orange Courier font.

Listing 1.6 An IDLE session with a Hello-World statement. Programmer input is shown in bold.

The information on the ﬁrst three lines will vary depending on the version and system.

1 Python 3.2.2 (v3.2.2:137e45f15c0b, Sep 3 2011, 17:28:59)

2 [GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin

3 Type "copyright", "credits" or "license()" for more information.

4 >>> print("Hello World!")

5 Hello World!

6 >>>

To execute the print() statement shown on line 4, one merely types in the statement as shown

and then hits the enter (or return) key.

An alternative way of running an interactive session with the Python interpreter is via the

command line.

To accomplish this on a Mac, go to the folder /Applications/Utilities

and open the application Terminal. After Terminal has started, type python3 and hit return.

IDLE is built using a graphics package known as tkinter which also comes with Python. When you use tkinter

graphics commands, sometimes they can interfere with IDLE so it’s probably best to open an interactive session using

the command line instead of IDLE.

10 CHAPTER 1. INTRODUCTION

For Windows, click the Start button and locate the program Python (command line) and

click on it.

Listing 1.7 shows the start of a command-line based interactive session. An important part of

programming is including comments for humans. These comments are intended for those who are

reading the code and trying to understand what it does. As you write more and more programs,

you will probably discover that the comments you write will often end up aiding you in trying to

understand what you previously wrote! The programmer input in Listing 1.7 starts with four lines

of comments which are shown in a slanted, orange Courier font. (One would usually not include

comments in an interactive session, but they are appropriate at times—especially in a classroom

setting!)

Listing 1.7 A command-line session with a Hello-World statement. Here lines 4 through 7 are

purely comments. Comment statements will be shown in a slanted, Courier font (instead of

bold).

1 Python 3.2.2 (v3.2.2:137e45f15c0b, Sep 3 2011, 17:28:59)

2 [GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin

3 Type "help", "copyright", "credits" or "license" for more information.

4 >>> # This is a comment. The interpreter ignores everything

5 ... # after the "#" character. In the command-line environment

6 ... # the prompt will change to "..." if "#" is the first

7 ... # character of the previous line.

8 ... print("Hello", "World!") # Comment following a statement.

9 Hello World!

10 >>>

Python treats everything after the character # as a comment, i.e., it simply ignores this text as

it is intended for humans and not the computer. The character # is called pound, hash, number

sign, or (rarely) octothorp. As line 8 demonstrates, a comment can appear on the same line as a

statement. (The # character does not indicate a comment if it is embedded in a string literal.) A

hash is used to indicate a comment whether using the Python interpreter or writing Python code in

a ﬁle. (String literals can also be used as comments as discussed in connection with doc strings in

Sec. 4.3.)

As Listing 1.7 shows, sometimes the Python prompt changes to three dots (...). This happens

in the command-line environment when Python is expecting more input (we will see later the

situations in which Python expects more input). In the command-line environment, when a line

starts with a comment, Python will change the prompt in the following line to three dots. However,

as shown in line 8 in Listing 1.7, a statement entered after the three dots will be executed as usual.

Things behave slightly differently in IDLE: the prompt will remain >>> in a line following a line

of comment. In this book, when showing an interactive session, we will typically adopt the IDLE

convention in which the prompt following a comment is still >>>.

There is one important feature of the interactive environment that, though useful, can lead to

confusion for those new to Python. The interactive environment will display the result of ex-

pressions (what we mean by an expression will be discussed further in Chap. 2) and will echo a

literal that is entered. So, for example, in the interactive environment, if we want to print Hello

1.6. RUNNING PYTHON 11

World!, we don’t need to use a print() statement. We can merely enter the string literal and

hit return. Listing 1.8 illustrates this where, on line 1, the programmer entered the literal string and

on line 2 Python echoed the message back. However, note that, unlike in Listing 1.7, the output is

surrounded by single quotes. We will have more to say about this below and in the next chapter.

Listing 1.8 When a literal is entered in the interactive environment, Python echoes the literal back

to the programmer.

1 >>> "Hello World!"

2 ’Hello World!’

3 >>>

1.6.2 Running Commands from a File

There are various ways you can store commands in a ﬁle and then have the Python interpreter act

on them. Here we will just consider how this can be done using IDLE. After starting IDLE, the

window that appears with the interactive prompt is titled Python Shell. Go to the File menu

and select New Window. Alternatively, on a Mac you can type command-N, while on a Windows

machine you would type control-N. Henceforth, when we refer to a keyboard shortcut such as C-

N, we mean command-N on a Mac and control-N under Windows. The letter following “C-” will

vary depending on the shortcut (although this trailing letter will be written in uppercase, it is not

necessary to press the shift key).

After selecting New Window or typing C-N, a new window will appear with the title Untitled.

No interactive prompt appears. You can enter Python statements in this window but the interpreter

will not act on these statements until you explicitly ask it to. Once you start typing in this window

the title will change to

Untitled

. The asterisks indicate that the contents of this window have

changed since the contents were last saved to a ﬁle.

Before we can run the statements in the window we opened, we must save the ﬁle. To do this,

either select Save from the File menu or type C-S. This will bring up a “Save” window where

you indicate the folder and the ﬁle name where you want the contents of the window to be saved.

Whatever ﬁle name you choose, you should save it with an extension of “.py” which indicates

this is a Python ﬁle. Once you have saved the ﬁle, the title of the Window will change to reﬂect the

new ﬁle name (and the folder where it is stored).

Once the ﬁle has been saved, it can be run through the Python interpreter. To do this, you

can either go to the Run menu and select Run Module or you can type F5 (function key 5—on a

Mac laptop you will have to hold down the fn key, too). To illustrate what happens now, assume a

programmer has entered and saved the two lines of code shown in Listing 1.9.

Listing 1.9 Two lines of code that we assume have been saved to a ﬁle via IDLE. (This code is

not entered directly in the interactive environment.)

If an expression is entered in the interactive environment, Python displays the result of the expression. Expressions

are discussed in Chap. 2.

12 CHAPTER 1. INTRODUCTION

1 "Hello World!"

2 print("Have we said enough hellos?")

When this is run, the focus will switch back to the Python Shell window. The window will contain

the output shown in Listing 1.10.

Listing 1.10 The output that is produced by running the code in Listing 1.9

1 >>> =========================== RESTART ===========================

2 >>>

3 Have we said enough hellos?

4 >>>

The output shown in the ﬁrst two lines is not something our code produced. Rather, whenever

IDLE runs the contents of a ﬁle, it restarts the Python interpreter (thus anything you previously

deﬁned, such as variables and functions, will be lost—this provides a clean start for running the

code in the ﬁle). This restart is announced as shown in line 1; it is followed by a “blank line,”

i.e., a line with the interactive prompt but nothing else. Then, in line 3 of Listing 1.10, we see

the output produced by the print() statement in line 2 of Listing 1.9. However, note that no

output was produced by the Hello World! literal on line 1 of Listing 1.9. In the interactive

environment, Hello World! is echoed to the screen, but when we put statements in a ﬁle, we

have to explicitly state what we want to show up on the screen.

If you make further changes to the ﬁle, you must save the contents before running the ﬁle

again.

To run the ﬁle you can simply type C-S (the save window that appeared when you ﬁrst

type C-S will not reappear—the contents will be saved to the ﬁle you speciﬁed previously) and

then F5.

1.7 Bugs

You should keep in mind that, for now, you cannot hurt your computer with any bugs or errors

you may write in your Python code. Furthermore, any errors you make will not crash the Python

interpreter. Later, when we consider opening or manipulating ﬁles, we will want to be somewhat

cautious that we don’t accidentally delete a ﬁle, but for now you shouldn’t hesitate to experiment

with code. If you ever have a question about whether something will or won’t work, there is no

harm in trying it out to see what happens.

Listing 1.11 shows an interactive session in which a programmer wanted to ﬁnd out what would

happen when entering modiﬁed versions of the Hello-World program. In line 2, the programmer

wanted to see if Print() could be use instead of print(). In line 7 the programmer attempted

to get rid of the parentheses. And, in line 13, the programmer tried to do away with the quotation

marks. Code that produces an error will generally be shown in red.

Note that we will say “run the ﬁle” although it is more correct to say “run the program contained in the ﬁle.”

剩余359页未读，继续阅读

weixin_38743481

粉丝: 696
资源: 4万+

使用Python解决算法问题：编程和算法思维入门

p.j. Schneider的毕业论文（interactive-curve-design)

Python库 | pyModbusTCP-0.1.6.tar.gz

FDTD算法的FPGA实现.pdf

《Managing Your Biological Data with Python》英文版PDF.pdf

WJSmisc:W. Joel Schneider的其他职能

Schneider.rar

Schneider-PLC-协同自动化-以太网架构解决方案PPT课件.ppt

Schneider按钮.pdf

Schneider Electric EcoStruxure.zip

schneider PLC Modbus.pdf

最新资源