物理建模的Python学习指南：探索编程的无限可能

需积分: 10 85 浏览量更新于2024-07-16 收藏 4.8MB PDF 举报

"A Student's Guide to Python for Physical Modeling (2015).pdf" 是一本面向物理建模学生的Python编程指南，由Jesse M. Kinder和Philip Nelson合著，由普林斯顿大学出版社出版。这本书旨在教授学生如何利用Python进行物理建模，通过学习编程技能，帮助学生实现更复杂的物理计算，如模拟摩擦力和空气阻力，创建生态系统中的捕食者-猎物模型等。在描述中，作者强调了学习Python的重要性，因为它能赋予学生几乎无限的计算能力，让他们能够处理在传统物理学课程中通常被忽略的细节。Python作为一种高级编程语言，以其易读性、丰富的库支持和广泛的应用领域而备受青睐，尤其适合科学计算和数据分析。本书可能涵盖了以下核心知识点： 1. Python基础知识：包括变量、数据类型（如整数、浮点数、字符串、列表、元组、字典等）、控制流（如if语句、for循环、while循环）和函数的使用。 2. 数值计算：使用NumPy库进行数值数组操作，包括矩阵运算、统计分析和复杂数学计算。 3. 科学绘图：使用Matplotlib库创建高质量的图表，用于可视化物理模型的结果，例如绘制曲线、散点图和图像。 4. 科学建模：讲解如何使用Python构建物理模型，如力学系统、热力学过程、电磁学问题等。 5. 数据处理：可能涉及Pandas库，用于处理和分析实验数据，进行数据清洗和预处理。 6. 模拟与仿真：介绍如何用Python实现动态系统的模拟，如ODE求解器（如SciPy的odeint函数）来解决微分方程。 7. 高级主题：可能包括面向对象编程、异常处理、模块和包的使用，以及可能的并行计算和性能优化。 8. 实例分析：书中可能包含多个物理模型的实战案例，帮助读者理解如何将所学应用于实际问题。通过这本教材，读者不仅能够掌握Python编程技术，还能了解到如何将这些技术应用于解决物理问题，提升科学建模和计算能力。同时，封面所示的Mandelbrot集合表明，书中还会涉及复杂数学和图形生成，进一步扩展了Python在物理建模中的应用范围。

C H A P T E R 1

Getting Started with Python

The Analytical Engine weaves algebraical patterns, just as the Jacquard loom

weaves ﬂowers and leaves.

— Ada, Countess of Lovelace, 1815–1853

1.1 ALGORITHMS AND ALGORITHMIC THINKING

The goal of this tutorial is to get you started in computational science using the computer language

Python. Python is open-source software. You can download, install, and use it anywhere. Many good

introductions exist, and more are written every year. This one is distinguished mainly by the fact

that it focuses on skills useful for solving problems in physical modeling.

Modeling a physical system can be a complicated task. Let’s take a look at how we can use the

powerful processors inside your computer to help.

1.1.1 Algorithmic thinking

Suppose that you need to instruct a friend how to back your car out of your driveway. Your friend

has never driven a car, but it’s an emergency, and your only communication channel is a phone

conversation before the operation begins.

You need to break the required task down into small, explicit steps that your friend understands

and can execute in sequence. For example, you might provide your friend the following set of

instructions:

1 Put the key in the ignition.

2 Turn the key until the car starts, then let go.

3 Push the button on the shift lever and move it to "Reverse."

4 ...

Unfortunately, for many cars this “code” won’t work, even if your friend understands each instruction:

It contains a bug. Before step 3, many cars require that the driver

Press down the left pedal.

Also, the shifter may be marked R instead of Reverse. It is diﬃcult at ﬁrst to get used to the high

degree of precision required when composing instructions like these.

Because you are giving the instructions in advance (your friend has no mobile phone), it’s also

wise to allow for contingencies:

If a crunching sound is heard, press down on the left pedal ...

2 Chapter 1 Getting Started with Python

Breaking the steps of a long operation down into small, explicit substeps and anticipating

contingencies are the beginning of algorithmic thinking.

If your friend has had a lot of experience watching people drive cars, then the instructions above

may be suﬃcient. But a friend from Mars—or a robot—would need much more detail. For example,

the ﬁrst two steps may need to be expanded to something like

Grab the wide end of the key.

Insert the pointed end of the key into the slot on the lower right side

of the steering column.

Rotate the key about its long axis in the clockwise direction

(when viewed from the wide end toward the pointed end).

...

A low-level computer program provides instructions analogous to these in a language that a machine

can understand.

A high-level system understands many common tasks, and therefore can be

programmed in a more condensed style, like the ﬁrst set of instructions above. Python is a high-level

language. It includes commands for common operations in mathematical calculations, processing text,

and manipulating ﬁles. In addition, Python can access many standard libraries, which are collections

of programs that perform advanced functions like data visualization and image processing.

Python comes with a command line interpreter —a program that executes Python commands

as you type them. Thus, in Python, you can type commands and execute them immediately. In

contrast, many other programming languages used in scientiﬁc computing, like C, C++, or fortran,

require you to compile your programs before you can execute them. A separate program called a

compiler translates your code into a low-level language. You then run the resulting compiled program

to execute (carry out) your algorithm. With Python, it is comparatively easy to quickly write, run,

and debug programs. (It still takes patience and practice, though.)

A command line interpreter combined with standard libraries and programs you write yourself

provides a convenient and powerful scientiﬁc computing platform.

1.1.2 States

You have probably studied multistep mathematical proofs, perhaps long ago in geometry class. The

goal of such a narrative is to establish the truth of a desired conclusion by sequentially appealing

to given information and a formal system. Thus, each statement’s truth, although not evident in

isolation, is supposed to be straightforward in light of the preceding statements. The reader’s “state”

(list of propositions known to be true) changes while reading through the proof. At the end of the

proof, there is an unbroken chain of logical deductions that lead from the axioms and assumptions to

the result.

algorithm

has a diﬀerent goal. It is a chain of instructions, each of which describes a simple

operation, that accomplishes a complex task. The chain may involve a lot of repetition, so you won’t

want to supervise the execution of every step. Instead, you specify all the steps in advance, then

stand back while your electronic assistant performs them rapidly. There may also be contingencies

that cannot be known in advance. (If a crunching sound is heard, ...)

In an algorithm, the computer has a state that is constantly being modiﬁed. For example, it has

many memory cells, whose contents may change during the course of an operation. Your goal might

Machine code and assembly language are low-level programming languages.

Jump to Contents Jump to Index

1.1 Algorithms and algorithmic thinking 3

be to arrange for one or more of these cells to contain the result of some complex calculation once

the algorithm has ﬁnished running. You may also want a particular graphical image to appear.

1.1.3 What does a = a + 1 mean?

To get a computer to execute your algorithm, you must communicate with it in a language it

understands. The commands used in computer programming can be confusing at ﬁrst, especially

when they contradict standard mathematical usage. For example, many programming languages

(including Python) accept statements such as these:

1 a = 100

2 a = a + 1

In mathematics, this makes no sense. The second line is an assertion that is always false; equivalently,

it is an equation with no solution. To Python, however, “=” is not a test of equality, but an instruction

to be executed. These lines have roughly the following meaning:

1. Assign the name a to an integer object with the value 100.

Extract the value of the object named

. Calculate the sum of that value and 1. Assign the name

a to the result, and discard whatever was previously stored under the name a.

In other words, the equals sign instructs Python to change its state. In contrast, mathematical

notation uses the equals sign to create a proposition, which may be true or false. Note, too, that

Python treats the left and right sides of the command

x=y

diﬀerently, whereas in math the equals

sign is symmetric. For example, Python will give an error message if you say something like b+1=a;

the left side of an assignment must be a name that can be assigned to the result of evaluating the

right side.

We do often wish to determine whether a variable has a particular value. To avoid ambiguity

between assignment and testing for equality, Python and many other computing languages use a

double equals sign for the latter:

1 a = 1

2 a == 0

3 b = (a == 1)

The above code again sets up a variable

and assigns it to a numerical value. Then it compares this

numerical value with 0. Finally, it creates a second variable

, and assigns it a logical value (

True

False

) after performing another comparison. That value can be used in contingent code, as we’ll see

later.

Do not use = (assignment) when == (test for equality) is required.

This is a common mistake for beginning programmers. You can get mysterious results if you make

this error, because both

and

are legitimate Python syntax. In any particular situation, however,

only one of them is what you want.

Appendix D gives more precise information about the handling of assignment statements.

Jump to Contents Jump to Index

4 Chapter 1 Getting Started with Python

1.1.4 Symbolic versus numerical

In math, it’s perfectly reasonable to start a derivation with “Let

− a

,” even if the reader

doesn’t yet know the value of

. This statement deﬁnes

in terms of

, whatever the value of

may

be.

If we launch Python and immediately give the equivalent statement,

b=a

2-a

, the result is

an error message.

Every time we hit

, Python tries to compute values for every

assignment statement. If the variable

has not been assigned a value yet, evaluation fails, and

Python complains. Other computer math packages can accept such input, keep track of the symbolic

relationship, and evaluate it later, but basic Python does not.

In math, it’s also understood that a deﬁnition like “Let

− a

” will persist unchanged

throughout the discussion. If we say, “In the case

= 1, . . . ” then the reader knows that

equals

zero; if later we say, “In the case

= 2, . . . ” then we need not reiterate the deﬁnition of

for the

reader to know that this symbol now represents the value 2

− 2 = 2.

In contrast, a numerical system like Python forgets any relation between

and

after executing

the assignment

b=a

2-a

. All that it remembers is the value now assigned to

. If we later change

the value of a, the value of b will not change.

Changing symbolic relationships in the middle of a proof is generally not a good idea. However,

in Python, if we say

b=a

2-a

, nothing stops us from later saying

b=2

. The second assignment

updates Python’s state by discarding the value calculated in the ﬁrst assignment statement and

replacing it with the newly computed value.

1.2 LAUNCH PYTHON

Rather than reading about what happens when you type some command, try out the commands for

yourself. From now on, you should have Python running as you read, try every snippet of code, and

observe what Python does in response. For example, this tutorial won’t show you any graphics or

output. You must generate these yourself as you work through the examples.

Reading this tutorial won’t teach you Python. You can teach yourself

Python by working through all the examples and exercises here, and then

using what you’ve learned on your own problems.

Set yourself little challenges and try them out. (“What would happen if . . . ?” “How could I accomplish

that?”) Python is not some expensive piece of lab apparatus that could break or explode if you type

something wrong! Just try things. This strategy is not only more fun than passively accumulating

facts—it is also far more eﬀective.

A complete Python programming environment has many components. See Table 1.1 for a brief

description of the ones that we’ll be discussing. Be aware that we use “Python” loosely in this guide.

In addition to the language itself, Python may refer to a Python interpreter, which is a computer

application that accepts commands and performs the steps described in a program. Python may also

refer to the language together with common libraries.

The notation

denotes exponentiation. See Section 1.4.2.

The SymPy library makes symbolic calculations possible in Python. See Section 7.3.1.

In math, the statement

− a

essentially deﬁnes

as a function of

. We can certainly do that in Python by

deﬁning a function that returns the value of a

− a and assigning that function the name b. The point is that this is

not what “=” does.

Jump to Contents Jump to Index

1.2 Launch Python 5

Python A computer programming language. A way to describe algorithms to a computer.

IPython

A Python interpreter: A computer application that provides a convenient, interactive

mode for executing Python commands and programs.

Spyder

An integrated development environment (IDE): A computer application that includes

IPython, a tool to inspect variables, a text editor for writing and debugging programs,

and more.

NumPy A standard library that provides numerical arrays and mathematical functions.

PyPlot A standard library that provides visualization tools.

SciPy A standard library that provides scientiﬁc computing tools.

Anaconda

A distribution: A single download that includes all of the above and provides access

to many additional libraries for special purposes. It also includes a package manager

that helps you to keep everything up to date.

Table 1.1: Elements of the Python environment described in this tutorial.

Appendix A describes how to install and launch Python. Most of the code that follows will run

with any Python distribution. However, since we cannot provide instructions for every available

version of Python and every integrated development environment (IDE), we have chosen the following

particular setup:

•

The Anaconda distribution of Python 3.4, available at

store.continuum.io/cshop/anaconda/

Many scientists use an earlier version of Python (such as version 2.7). Appendix C discusses the

two minor changes needed to adapt the codes in this tutorial for earlier versions.

•

The Spyder IDE, which comes with Anaconda or can be downloaded at

code.google.com/p/spyderlib/.

Any programming task can be accomplished with a diﬀerent IDE—or with no IDE at all—but this

tutorial will assume you are using Spyder. Other IDEs are available, such as IDLE, which comes

with every distribution of Python, and Web-based IPython Notebooks.

The choice of distribution is a matter of personal preference. We chose Anaconda because it is simple

to install, update, and maintain, and it is free. You may ﬁnd a diﬀerent distribution is better suited

to your needs. Enthought Canopy is another free, widely used Python distribution.

1.2.1 IPython console

Upon launch, Spyder opens a window that includes several panes. See Figure 1.1.

There is an Editor pane on the left for editing program ﬁles (scripts). There are two panes on

the right. The top one may contain Object Inspector, Variable Explorer, and File Explorer tabs. If

necessary, click on the Variable Explorer tab to bring it to the front. The bottom-right pane should

include a tab called “IPython Console”; if necessary, click it now.

It provides the command line

interpreter that allows you to execute Python commands interactively as you type them.

If your window layout gets disorganized, do not worry. It is easy to adjust. The standard format

for Spyder is to open with a single window, divided into the three panes just described. Each pane

can have multiple tabs. If you have unwanted windows, close them individually by clicking on their

“Close” buttons. You can also use the menu

View>Panes

to select panes you want to be visible and

deactivate those you do not want.

View>Reset window layout

will restore the standard layout, but

If no IPython console tab is present, you can open one from the menu at the top of the screen:

Consoles>Open an

IPython console.

Jump to Contents Jump to Index

剩余153页未读，继续阅读

橙心橙意JCLiu

粉丝: 0
资源: 5

物理建模的Python学习指南：探索编程的无限可能

A Student's Guide to Python for Physical Modeling 无水印pdf 0分

A Student’s Guide to Python for Physical Modeling

open cascade python

python distfit

keras cudnngru

c++调用 python 导入 astropy.modeling模块异常

Python ARIMA

ImportError: cannot import name 'modeling'

sybase.modeling.nmap.runtime

最新资源