ACrashCourseinPythonforScientists资源-CSDN文库

需积分: 15 114 浏览量 2017-12-05 17:52:51 上传评论收藏 2.08MB PDF 举报

Python语言对于科学家而言，是一个不可或缺的工具，它之所以受到广大科学工作者的青睐，有以下几个重要原因： 1. 学习成本低：Python相对于其他编程语言而言，入门相对容易，可以在短时间内掌握基本知识，并迅速应用到科学数据的分析和建模中。 2. 开发效率高：Python提供了强大的数据处理能力，使得科研人员在分析和建模科学数据时，能够以较小的开发成本取得显著的成效。 3. 易于安装和部署：Python的安装和配置相对简单，无需复杂的配置过程，这使得科学家们可以将更多时间投入到科研工作本身，而非编程环境的搭建。 4. 丰富的科学计算库：Python拥有广泛的科学计算库，例如NumPy, SciPy和Matplotlib等，这些库支持各种科学计算任务，包括矩阵运算、统计分析、图形绘制等。 5. 长期使用性：一旦掌握Python，科研人员可以终身受用，因为Python在不断更新和改进，且有着稳定的社区支持。此外，本课程还提到了一些有助于科学家深入学习Python的重要资源和工具： 1. Python官方教程：官方网站提供了一个全面的Python教程（***），是学习Python基础知识的好去处。 2. IPython项目：IPython项目提供了一个功能强大的笔记本界面，它集成了代码执行、文本编辑、数学公式和图形展示等多种功能，极大地提高了数据科学和科学计算的效率。 3. IPython笔记本资源：网络上有许多优秀的IPython笔记本资源，包括Rob Johansson的科学计算和量子物理教程（***），以及使用matplotlib绘图的各种风格，比如XKCD风格的图表（***）。 4. IPython的有效使用笔记本集：包含了各种有效的IPython使用方法的笔记本集，为科学家们提供了一系列使用Python进行数据科学工作的高级示例（***）。该课程的内容设计紧跟科学界的需求，侧重于以下几个方面： 1. 解析其他程序的输出：掌握如何用Python解析来自其他科学计算程序的输出数据，以便进一步分析。 2. 构建简单模型：通过编写Python脚本来构建和测试科学模型，这有助于理解科学现象并预测其行为。 3. 面向对象编程：学习如何利用Python进行面向对象编程，这对于开发可复用和模块化的科学软件非常重要。 4. 使用C语言扩展Python：由于Python的执行速度限制，有时需要使用C语言等底层语言来提高性能，本课程将教授如何将Python与C语言进行集成。 5. 简单的图形用户界面（GUI）设计：创建一个图形用户界面，使得非编程背景的科学家也能方便地使用编写好的程序。该课程是由Rick Muller教授于Sandia国家实验室开发，并且通过创造性公共许可证（Creative Commons Attribution-ShareAlike 3.0 Unported License）发布，这意味着该资源可以被广泛分享和使用。

资源推荐

资源详情

资源评论

A Crash Course in Python for Scientists
Rick Muller (http://www.cs.sandia.gov/~rmuller/), Sandia National Laboratories
version 0.6
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License
(http://creativecommons.org/licenses/by-sa/3.0/deed.en_US).
Why Python?
Python is the programming language of choice for many scientists to a large degree because it offers a great deal of power
to analyze and model scientific data with relatively little overhead in terms of learning, installation or development time. It is
a language you can pick up in a weekend, and use for the rest of one's life.
The Python Tutorial (http://docs.python.org/2/tutorial/) is a great place to start getting a feel for the language. To
complement this material, I taught a Python Short Course (http://www.wag.caltech.edu/home/rpm/python_course/) years
ago to a group of computational chemists during a time that I was worried the field was moving too much in the direction of
using canned software rather than developing one's own methods. I wanted to focus on what working scientists needed to
be more productive: parsing output of other programs, building simple models, experimenting with object oriented
programming, extending the language with C, and simple GUIs.
I'm trying to do something very similar here, to cut to the chase and focus on what scientists need. In the last year or so, the
IPython Project (http://ipython.org) has put together a notebook interface that I have found incredibly valuable. A large
number of people have released very good IPython Notebooks that I have taken a huge amount of pleasure reading
through. Some ones that I particularly like include:
Rob Johansson's excellent notebooks (http://jrjohansson.github.io/), including Scientific Computing with Python
(https://github.com/jrjohansson/scientific-python-lectures) and Computational Quantum Physics with QuTiP
(https://github.com/jrjohansson/qutip-lectures) lectures;
XKCD style graphs in matplotlib
(http://nbviewer.ipython.org/url/jakevdp.github.com/downloads/notebooks/XKCD_plots.ipynb);
A collection of Notebooks for using IPython effectively
(https://github.com/ipython/ipython/tree/master/examples/notebooks#a-collection-of-notebooks-for-using-
ipython-effectively)
A gallery of interesting IPython Notebooks (https://github.com/ipython/ipython/wiki/A-gallery-of-interesting-
IPython-Notebooks)
I find IPython notebooks an easy way both to get important work done in my everyday job, as well as to communicate what
I've done, how I've done it, and why it matters to my coworkers. I find myself endlessly sweeping the IPython subreddit
(http://ipython.reddit.com) hoping someone will post a new notebook. In the interest of putting more notebooks out into the
wild for other people to use and enjoy, I thought I would try to recreate some of what I was trying to get across in the
original Python Short Course, updated by 15 years of Python, Numpy, Scipy, Matplotlib, and IPython development, as well
as my own experience in using Python almost every day of this time.
What You Need to Install
There are two branches of current releases in Python: the older-syntax Python 2, and the newer-syntax Python 3. This
schizophrenia is largely intentional: when it became clear that some non-backwards-compatible changes to the language
were necessary, the Python dev-team decided to go through a five-year (or so) transition, during which the new language
features would be introduced and the old language was still actively maintained, to make such a transition as easy as
possible. We're now (2013) past the halfway point, and, IMHO, at the first time when I'm considering making the change to
Python 3.
Nonetheless, I'm going to write these notes with Python 2 in mind, since this is the version of the language that I use in my
day-to-day job, and am most comfortable with. If these notes are important and are valuable to people, I'll be happy to
rewrite the notes using Python 3.
With this in mind, these notes assume you have a Python distribution that includes:
Python (http://www.python.org) version 2.7;
Numpy (http://www.numpy.org), the core numerical extensions for linear algebra and multidimensional arrays;
Scipy (http://www.scipy.org), additional libraries for scientific programming;
Matplotlib (http://matplotlib.sf.net), excellent plotting and graphing libraries;
IPython (http://ipython.org), with the additional libraries required for the notebook interface.
A good, easy to install option that supports Mac, Windows, and Linux, and that has all of these packages (and much more)
is the Entought Python Distribution (https://www.enthought.com/products/epd), also known as EPD, which appears to be
changing its name to Enthought Canopy. Enthought is a commercial company that supports a lot of very good work in

scientific Python development and application. You can either purchase a license to use EPD, or there is also a free version

(https://www.enthought.com/products/epd/free/) that you can download and install.

Here are some other alternatives, should you not want to use EPD:

Linux Most distributions have an installation manager. Redhat has yum, Ubuntu has apt-get. To my knowledge, all of these

packages should be available through those installers.

Mac I use Macports (http://www.macports.org/), which has up-to-date versions of all of these packages.

Windows The PythonXY (https://code.google.com/p/pythonxy/) package has everything you need: install the package, then

go to Start > PythonXY > Command Prompts > IPython notebook server.

Cloud This notebook is currently not running on the IPython notebook viewer (http://nbviewer.ipython.org/), but will be

shortly, which will allow the notebook to be viewed but not interactively. I'm keeping an eye on Wakari

(http://www.wakari.io), from Continuum Analytics (http://continuum.io/), which is a cloud-based IPython notebook. Wakari

appears to support free accounts as well. Continuum is a company started by some of the core Enthought Numpy/Scipy

people focusing on big data.

Continuum also supports a bundled, multiplatform Python package called Anaconda (https://store.continuum.io/) that I'll

also keep an eye on.

I. Python Overview

This is a quick introduction to Python. There are lots of other places to learn the language more thoroughly. I have collected

a list of useful links, including ones to other learning resources, at the end of this notebook. If you want a little more depth,

Python Tutorial (http://docs.python.org/2/tutorial/) is a great place to start, as is Zed Shaw's Learn Python the Hard Way

(http://learnpythonthehardway.org/book/).

The lessons that follow make use of the IPython notebooks. There's a good introduction to notebooks in the IPython

notebook documentation (http://ipython.org/notebook.html) that even has a nice video (http://www.youtube.com/watch?

v=H6dLGQw9yFQ#!) on how to use the notebooks. You should probably also flip through the IPython tutorial

(http://ipython.org/ipython-doc/dev/interactive/tutorial.html) in your copious free time.

Briefly, notebooks have code cells (that are generally followed by result cells) and text cells. The text cells are the stuff that

you're reading now. The code cells start with "In []:" with some number generally in the brackets. If you put your cursor in

the code cell and hit Shift-Enter, the code will run in the Python interpreter and the result will print out in the output cell. You

can then change things around and see whether you understand what's going on. If you need to know more, see the

IPython notebook documentation (http://ipython.org/notebook.html) or the IPython tutorial (http://ipython.org/ipython-

doc/dev/interactive/tutorial.html).

Using Python as a Calculator

Many of the things I used to use a calculator for, I now use Python for:

In[1]:

2+2

In[2]:

(50-5*6)/4

(If you're typing this into an IPython notebook, or otherwise using notebook file, you hit shift-Enter to evaluate a cell.)

There are some gotchas compared to using a normal calculator.

In[3]:

7/3

Python integer division, like C or Fortran integer division, truncates the remainder and returns an integer. At least it does in

version 2. In version 3, Python returns a floating point number. You can get a sneak preview of this feature in Python 2 by

importing the module from the future features:

from __future__ import division

Alternatively, you can convert one of the integers to a floating point number, in which case the division function returns

another floating point number.

Out[1]: 4

Out[2]:

Out[3]: 2

In[4]:

7/3.

In[5]:

7/float(3)

In the last few lines, we have sped by a lot of things that we should stop for a moment and explore a little more fully. We've

seen, however briefly, two different data types: integers, also known as whole numbers to the non-programming world, and

floating point numbers, also known (incorrectly) as decimal numbers to the rest of the world.

We've also seen the first instance of an import statement. Python has a huge number of libraries included with the

distribution. To keep things simple, most of these variables and functions are not accessible from a normal Python

interactive session. Instead, you have to import the name. For example, there is a math module containing many useful

functions. To access, say, the square root function, you can either first

from math import sqrt

and then

In[6]:

sqrt(81)

or you can simply import the math library itself

In[7]:

import math

math.sqrt(81)

You can define variables using the equals (=) sign:

In[8]:

width = 20

length = 30

area = length*width

area

If you try to access a variable that you haven't yet defined, you get an error:

In[9]:

volume

and you need to define it:

In[]:

depth = 10

volume = area*depth

volume

You can name a variable almost anything you want. It needs to start with an alphabetical character or "_", can contain

alphanumeric charcters plus underscores ("_"). Certain words, however, are reserved for the language:

and, as, assert, break, class, continue, def, del, elif, else, except,

exec, finally, for, from, global, if, import, in, is, lambda, not, or,

pass, print, raise, return, try, while, with, yield

Trying to define a variable using one of these will result in a syntax error:

Out[4]: 2.3333333333333335

Out[5]:

2.3333333333333335

Out[6]: 9.0

Out[7]: 9.0

Out[8]:

600

---------------------------------------------------------------------------

NameError Traceback (most recent call last)

<ipython-input-9-0c7fc58f9268> in <module>()

----> 1 volume

NameError: name 'volume' is not defined

In[20]:

print "This " + "is " + "a " + "longer " + "statement."

If you have a lot of words to concatenate together, there are other, more efficient ways to do this. But this is fine for linking a

few strings together.

Lists

Very often in a programming language, one wants to keep a group of similar items together. Python does this using a data

type called lists.

In[21]:

days_of_the_week = ["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"]

You can access members of the list using the index of that item:

In[22]:

days_of_the_week[2]

Python lists, like C, but unlike Fortran, use 0 as the index of the first element of a list. Thus, in this example, the 0 element is

"Sunday", 1 is "Monday", and so on. If you need to access the nth element from the end of the list, you can use a negative

index. For example, the -1 element of a list is the last element:

In[23]:

days_of_the_week[-1]

You can add additional items to the list using the .append() command:

In[24]:

languages = ["Fortran","C","C++"]

languages.append("Python")

print languages

The range() command is a convenient way to make sequential lists of numbers:

In[25]:

range(10)

Note that range(n) starts at 0 and gives the sequential list of integers less than n. If you want to start at a different number,

use range(start,stop)

In[26]:

range(2,8)

The lists created above with range have a step of 1 between elements. You can also give a fixed step size via a third

command:

In[27]:

evens = range(0,20,2)

evens

In[28]:

evens[3]

Lists do not have to hold the same data type. For example,

In[29]:

["Today",7,99.3,""]

However, it's good (but not essential) to use lists for similar objects that are somehow logically connected. If you want to

group different data types together into a composite data object, it's best to use tuples, which we will learn about below.

This is a longer statement.

Out[22]: 'Tuesday'

Out[23]:

'Saturday'

['Fortran', 'C', 'C++', 'Python']

Out[25]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Out[26]:

[2, 3, 4, 5, 6, 7]

Out[27]: [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

Out[28]:

Out[29]: ['Today', 7, 99.3, '']

剩余54页未读，继续阅读

评论收藏

内容反馈

eeabcde

粉丝: 0
资源: 15

A Crash Course in Python for Scientists

Crash-Course-on-Python-

Python_Crash_Course

Python for Scientists, 2nd Edition(2017).pdf

Python for Scientists 第二版 2017

Python for Scientists(2nd) azw3

Python for Scientists(2nd) epub

Python Crash Course课程资源

Python Crash Course 英文原版 pdf

Python-Crash-Course-por-Sigmoidal-

A first course in turbulence

Python for R Users

Fortran for Scientists & Engineers [4th Edition, 2017]

Python for Bioinformatics, Second Edition

Python Crash Course, 2nd Edition (ePUB)

Python-Crash-Course：只是另一个存储库

Python Crash Course: 2.Numbers, Strings, Comments

Python Crash Course 2016 Eric Mattes

Python Crash Course(NoStarch,2015)

Introduction to Python for Engineers and Scientists -(2018)

工程师与科学家用数值计算C语言库,A numerical library in C for scientists and engineers

Udemy - Deep Learning Convolutional Neural Networks in Python

Bernard Liengme A Guide to Microsoft Excel 2013 for Scientists and Engineers.pdf

最新资源