Python编程入门基础教程

下载需积分: 9 | PDF格式 | 13.1MB | 更新于2024-07-22 | 78 浏览量 | 举报

1 收藏

"Introduction to Computation and Programming Using Python"是一本由MIT（麻省理工学院）教师编写的教材，专门用于教授Python编程语言。该书的修订和扩展版由John V. Guttag撰写，并由MIT Press出版。这本书的版权归属于2013年的麻省理工学院，所有权利受到法律保护，未经书面许可，不得通过任何形式（包括电子或机械方式，如影印、录音或信息存储和检索）复制本书内容。 MIT Press的书籍可以以特殊折扣批量购买，适用于商业或销售推广用途。如果对批量购买感兴趣，可以通过电子邮件special_sales@mitpress.mit.edu或写信至Special Sales Department, The MIT Press, 55 Hayward Street, Cambridge, MA 02142获取更多信息。这本书在美国印刷装订，并在美国国会图书馆进行了编目注册。主要知识点： 1. **Python编程基础**：作为一本教材，本书会涵盖Python编程的基础概念，如变量、数据类型（如整型、浮点型、字符串）、控制结构（如条件语句和循环）、函数定义与调用等。 2. **算法与问题解决**：书中可能会介绍如何使用Python来设计和实现算法，解决实际问题，包括排序、搜索等经典算法。 3. **面向对象编程**：由于Python支持面向对象编程，教材可能会讲解类、对象、继承、封装和多态等面向对象编程的核心概念。 4. **数据结构**：书中可能会详细讨论Python中的各种数据结构，如列表、元组、字典和集合，以及如何有效地使用它们来组织和操作数据。 5. **文件操作与输入/输出**：介绍如何在Python中读写文件，进行标准输入输出，以及处理各种格式的数据文件。 6. **异常处理**：教授如何在代码中捕获和处理错误，使用try/except块来编写健壮的程序。 7. **模块与包**：讨论如何利用Python的模块和包系统，管理和重用代码。 8. **调试与测试**：介绍调试技巧和单元测试，帮助学生理解如何确保代码的正确性。 9. **软件工程实践**：可能涉及版本控制、项目组织、文档编写等软件开发过程中的最佳实践。 10. **计算机科学基础**：除了编程技能，还可能包含计算机科学的基本原理，如计算理论、数据表示和计算机体系结构的简介。这本书适合初学者，旨在通过Python语言介绍计算思维和编程基础，同时也适合已经有一定编程经验的人深入学习Python语言和计算机科学原理。

ACKNOWLEDGMENTS

This book grew out of a set of lecture notes that I prepared while teaching an

undergraduate course at MIT. The course, and therefore this book, benefited

from suggestions from faculty colleagues (especially Eric Grimson, Srinivas

Devadas, and Fredo Durand), teaching assistants, and the students who took

the course.

The process of transforming my lecture notes into a book proved far more

onerous than I had expected. Fortunately, this misguided optimism lasted long

enough to keep me from giving up. The encouragement of colleagues and family

also helped keep me going.

Eric Grimson, Chris Terman, and David Guttag provided vital help. Eric, who is

MIT’s Chancellor, managed to find the time to read almost the entire book with

great care. He found numerous errors (including an embarrassing, to me,

number of technical errors) and pointed out places where necessary

explanations were missing. Chris also read parts of the manuscript and

discovered errors. He also helped me battle Microsoft Word, which we

eventually persuaded to do most of what we wanted. David overcame his

aversion to computer science, and proofread multiple chapters.

Preliminary versions of this book were used in the MIT course 6.00 and the MITx

course 6.00x. A number of students in these courses pointed out errors. One

6.00x student, J.C. Cabrejas, was particularly helpful. He found a large number

of typos, and more than a few technical errors.

Like all successful professors, I owe a great deal to my graduate students. The

photo on the back cover of this book depicts me supporting some of my current

students. In the lab, however, it is they who support me. In addition to doing

great research (and letting me take some of the credit for it), Guha

Balakrishnan, Joel Brooks, Ganeshapillai Gartheeban, Jen Gong, Yun Liu,

Anima Singh, Jenna Wiens, and Amy Zhao all provided useful comments on this

manuscript.

I owe a special debt of gratitude to Julie Sussman, P.P.A. Until I started working

with Julie, I had no idea how much difference an editor could make. I had

worked with capable copy editors on previous books, and thought that was what

I needed for this book. I was wrong. I needed a collaborator who could read the

book with the eyes of a student, and tell me what needed to be done, what

should be done, and what could be done if I had the time and energy to do it.

Julie buried me in “suggestions” that were too good to ignore. Her combined

command of both the English language and programming is quite remarkable.

Finally, thanks to my wife, Olga, for pushing me to finish and for pitching in at

critical times.

1 GETTING STARTED

A computer does two things, and two things only: it performs calculations and it

remembers the results of those calculations. But it does those two things

extremely well. The typical computer that sits on a desk or in a briefcase

performs a billion or so calculations a second. It’s hard to image how truly fast

that is. Think about holding a ball a meter above the floor, and letting it go. By

the time it reaches the floor, your computer could have executed over a billion

instructions. As for memory, a typical computer might have hundreds of

gigabytes of storage. How big is that? If a byte (the number of bits, typically

eight, required to represent one character) weighed one ounce (which it doesn’t),

100 gigabytes would weigh more than 3,000,000 tons. For comparison, that’s

roughly the weight of all the coal produced in a year in the U.S.

For most of human history, computation was limited by the speed of calculation

of the human brain and the ability to record computational results with the

human hand. This meant that only the smallest problems could be attacked

computationally. Even with the speed of modern computers, there are still

problems that are beyond modern computational models (e.g., understanding

climate change), but more and more problems are proving amenable to

computational solution. It is our hope that by the time you finish this book, you

will feel comfortable bringing computational thinking to bear on solving many of

the problems you encounter during your studies, work, and even everyday life.

What do we mean by computational thinking?

All knowledge can be thought of as either declarative or imperative. Declarative

knowledge is composed of statements of fact. For example, “the square root of x

is a number y such that y

y = x.” This is a statement of fact. Unfortunately it

doesn’t tell us how to find a square root.

Imperative knowledge is “how to” knowledge, or recipes for deducing

information. Heron of Alexandria was the first to document a way to compute

the square root of a number.

His method can be summarized as:

• Start with a guess, g.

• If g

g is close enough to x, stop and say that g is the answer.

• Otherwise create a new guess by averaging g and x/g, i.e., (g + x/g)/2.

• Using this new guess, which we again call g, repeat the process until g

is close enough to x.

Many believe that Heron was not the inventor of this method, and indeed there is some

evidence that it was well known to the ancient Babylonians.

2 Chapter 1. Getting Started

Consider, for example, finding the square root of 25.

1. Set g to some arbitrary value, e.g., 3.

2. We decide that 3

3 = 9 is not close enough to 25.

3. Set g to (3 + 25/3)/2 = 5.67.

4. We decide that 5.67

5.67 = 32.15 is still not close enough to 25.

5. Set g to (5.67 + 25/5.67)/2 = 5.04

6. We decide that 5.04

5.04 = 25.4 is close enough, so we stop and declare 5.04

to be an adequate approximation to the square root of 25.

Note that the description of the method is a sequence of simple steps, together

with a flow of control that specifies when each step is to be executed. Such a

description is called an algorithm.

This algorithm is an example of a guess-

and-check algorithm. It is based on the fact that it is easy to check whether or

not a guess is a good one.

A bit more formally, an algorithm is a finite list of instructions that describe a

computation that when executed on a provided set of inputs will proceed

through a set of well-defined states and eventually produce an output.

An algorithm is a bit like a recipe from a cookbook:

1. Put custard mixture over heat.

2. Stir.

3. Dip spoon in custard.

4. Remove spoon and run finger across back of spoon.

5. If clear path is left, remove custard from heat and let cool.

6. Otherwise repeat.

It includes some tests for deciding when the process is complete, as well as

instructions about the order in which to execute instructions, sometimes

jumping to some instruction based on a test.

So how does one capture this idea of a recipe in a mechanical process? One way

would be to design a machine specifically intended to compute square roots.

Odd as this may sound, the earliest computing machines were, in fact, fixed-

program computers, meaning they were designed to do very specific things, and

were mostly tools to solve a specific mathematical problem, e.g., to compute the

trajectory of an artillery shell. One of the first computers (built in 1941 by

Atanasoff and Berry) solved systems of linear equations, but could do nothing

else. Alan Turing’s bombe machine, developed during World War II, was

designed strictly for the purpose of breaking German Enigma codes. Some very

simple computers still use this approach. For example, a four-function

calculator is a fixed-program computer. It can do basic arithmetic, but it cannot

For simplicity, we are rounding results.

The word “algorithm” is derived from the name of the Persian mathematician

Muhammad ibn Musa al-Khwarizmi.

Chapter 1. Getting Started 3

be used as a word processor or to run video games. To change the program of

such a machine, one has to replace the circuitry.

The first truly modern computer was the Manchester Mark 1.

It was

distinguished from its predecessors by the fact that it was a stored-program

computer. Such a computer stores (and manipulates) a sequence of

instructions, and has a set of elements that will execute any instruction in that

sequence. By creating an instruction-set architecture and detailing the

computation as a sequence of instructions (i.e., a program), we make a highly

flexible machine. By treating those instructions in the same way as data, a

stored-program machine can easily change the program, and can do so under

program control. Indeed, the heart of the computer then becomes a program

(called an interpreter) that can execute any legal set of instructions, and thus

can be used to compute anything that one can describe using some basic set of

instructions.

Both the program and the data it manipulates reside in memory. Typically there

is a program counter that points to a particular location in memory, and

computation starts by executing the instruction at that point. Most often, the

interpreter simply goes to the next instruction in the sequence, but not always.

In some cases, it performs a test, and on the basis of that test, execution may

jump to some other point in the sequence of instructions. This is called flow of

control, and is essential to allowing us to write programs that perform complex

tasks.

Returning to the recipe metaphor, given a fixed set of ingredients a good chef

can make an unbounded number of tasty dishes by combining them in different

ways. Similarly, given a small fixed set of primitive elements a good programmer

can produce an unbounded number of useful programs. This is what makes

programming such an amazing endeavor.

To create recipes, or sequences of instructions, we need a programming

language in which to describe these things, a way to give the computer its

marching orders.

In 1936, the British mathematician Alan Turing described a hypothetical

computing device that has come to be called a Universal Turing Machine. The

machine had an unbounded memory in the form of tape on which one could

write zeros and ones, and some very simple primitive instructions for moving,

reading, and writing to the tape. The Church-Turing thesis states that if a

function is computable, a Turing Machine can be programmed to compute it.

The “if” in the Church-Turing thesis is important. Not all problems have

computational solutions. For example, Turing showed that it is impossible to

write a program that given an arbitrary program, call it P, prints true if and only

if P will run forever. This is known as the halting problem.

This computer was built at the University of Manchester, and ran its first program in

1949. It implemented ideas previously described by John von Neumann and was

anticipated by the theoretical concept of the Universal Turing Machine described by Alan

Turing in 1936.

剩余314页未读，继续阅读

身份认证购VIP最低享 7 折!

30元优惠券

sinat_17031397

粉丝: 0

Python编程入门基础教程

Python编程入门与实践

Python编程入门：麻省理工学院教材解析

MIT教授John Guttag的Python编程教材简介

Introduction to Computation and Programming Using Python

Introduction to Computation and Programming Using Python,

Introduction to Computation and Programming Using Python 2nd

Introduction to Computation and Programming using Python 2013版

《Introduction to Computation and Programming Using Python》一书源代码

Introduction to Computation and Programming Using Python(2nd) epub 0分

Introduction to Computation and Programming Using Python 核对勘误至18年1月

最新资源