linux python科学计算,[python]科学计算

麻烦转载的朋友，请标明出处，作者，让我也小小虚荣一下。。。这都是我花了好多时间整理出来的。

谢谢各位捧场。。。

进行命令行，输入 python ,import  numpy as np 导入函数库。

1、创建数组   c = np.array([[1, 2, 3, 4],[4, 5, 6, 7], [7, 8, 9, 10]])

c.shape=3,4,通过改变c.shape的值改变数组的组合，某一值为-1时，自动计算，但必须保证总元数是两个值的积。

>>> d = a.reshape((2,2))     创建一个改变组合的数组，原数组不变

>>> d

array([[1, 2],

[3, 4]])

>>> a

array([1, 2, 3, 4])

数组a和d其实共享数据存储内存区域，因此修改其中任意一个数组的元素都会同时修改另外一个数组

的内容：

>>> np.array([[1, 2, 3, 4],[4, 5, 6, 7], [7, 8, 9, 10]], dtype=np.float)   改变数组元素类型，如int,complex,float等。

2、Numpy 提供了几个更加好用的创建数组的函数：

1) arange函数类似于python的range函数，通过指定开始值、终值和步长来创建一维数组，注意数组不包括终值:

>>> np.arange(0,1,0.1)

array([ 0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])

2)linspace函数通过指定开始值、终值和元素个数来创建一维数组，可以通过endpoint关键字指定是否包括终值，缺省设置是包括终值:

>>> np.linspace(0, 1, 12)

array([ 0. , 0.09090909, 0.18181818, 0.27272727, 0.36363636,0.45454545, 0.54545455, 0.63636364, 0.72727273, 0.81818182,0.90909091, 1. ])

np.linspace(start,end,num), 产生一等差数组，一共产生num个数，整个数组分成 num-1段，总长度 num-start，所以每段是unit=(num-start)/(num-1),每个数从start开始，每次加unit. 上式是一共产生12个数，分成11段，总长12-0，所以每段12/11。所以从0开始，每次加12/11.

3)logspace  产生等比数列

>>> np.logspace(0, 2, 20)

array([ 1. , 1.27427499, 1.62377674, 2.06913808,2.6366509 , 3.35981829, 4.2813324 , 5.45559478,

6.95192796, 8.8586679 , 11.28837892, 14.38449888,18.32980711, 23.35721469, 29.76351442, 37.92690191,48.32930239, 61.58482111, 78.47599704, 100. ])

起点：10^0=1,终点：10^2=100,函数log()以e为底，e=2.718,上例是创建一个1~100的20个等比数组

4)fromstring()  从字符串里创建数组

Python的字符串实际上是字节序列，每个字符占一个字节，，因此如果从字符串s创建一个8bit的整数数组的话，所得到的数组正好就是字符串中每个字符的ASCII编码:

>>> np.fromstring(s, dtype=np.int8)

array([ 97, 98, 99, 100, 101, 102, 103, 104], dtype=int8)

如果从字符串s创建16bit的整数数组，那么两个相邻的字节就表示一个整数，把字节98和字节97当作一个16位的整数，它的值就是98*256+97 = 25185。可以看出内存中是以little endian(低位字节在前)方式保存数据的。

>>> np.fromstring(s, dtype=np.int16)

array([25185, 25699, 26213, 26727], dtype=int16)

>>> 98*256+97

25185

5)将数组下标转换为数组中对应的值，然后使用此函数创建数组：

>>> def func(i):

... return i%4+1

...

>>> np.fromfunction(func, (10,))

array([ 1., 2., 3., 4., 1., 2., 3., 4., 1., 2.])

fromfunction函数的第一个参数为计算每个数组元素的函数，第二个参数为数组的大小(shape)，因为它支持多维数组，所以第二个参数必须是一个序列，本例中用(10,)创建一个10元素的一维数组。下面的例子创建一个二维数组表示九九乘法表，输出的数组a中的每个元素a[i, j]都等于func2(i, j)：

>>> def func2(i, j):

... return (i+1) * ( j+1)

...

>>> a = np.fromfunction(func2, (9,9))

6)取数

>>> a

array([ 0, 1, 100, 101, 4, 5, 6, 7, 8, 9])

>>> a[1:-1:2]    # 范围中的第三个参数表示步长，2表示隔一个元素取一个元素

array([ 1, 101, 5, 7])

>>> a[::-1] # 省略范围的开始下标和结束下标，步长为-1，整个数组头尾颠倒

array([ 9, 8, 7, 6, 5, 4, 101, 100, 1, 0])

>>> a[5:1:-2] # 步长为负数时，开始下标必须大于结束下标

array([ 5, 101])

和Python的列表序列不同，通过下标范围获取的新的数组是原始数组的一个视图。它与原始数组共享

同一块数据空间：

>>> b = a[3:7] # 通过下标范围产生一个新的数组b，b和a共享同一块数据空间

>>> b

array([101, 4, 5, 6])

>>> b[2] = -10 # 将b的第2个元素修改为-10

>>> b

array([101, 4, -10, 6])

>>> a # a的第5个元素也被修改为10

array([ 0, 1, 100, 101, 4, -10, 6, 7, 8, 9])

当使用整数序列对数组元素进行存取时，将使用整数序列中的每个元素作为下标，整数序列可以是列

表或者数组。使用整数序列作为下标获得的数组不和原始数组共享数据空间。

>>> x = np.arange(10,1,-1)

>>> x

array([10, 9, 8, 7, 6, 5, 4, 3, 2])

>>> x[[3, 3, 1, 8]] # 获取x中的下标为3, 3, 1, 8的4个元素，组成一个新的数组

array([7, 7, 9, 2])

>>> b = x[np.array([3,3,-3,8])] #下标可以是负数   先将取的数转换成数组

>>> b[2] = 100

>>> b

array([7, 7, 100, 2])

>>> x # 由于b和x不共享数据空间，因此x中的值并没有改变

array([10, 9, 8, 7, 6, 5, 4, 3, 2])

>>> x[[3,5,1]] = -1, -2, -3 # 整数序列下标也可以用来修改元素的值

>>> x

array([10, -3, 8, -1, 6, -2, 4, 3, 2])

当使用布尔数组b作为下标存取数组x中的元素时，将收集数组x中所有在数组b中对应下标为True的元素。使用布尔数组作为下标获得的数组不和原始数组共享数据空间。

>>> x

array([5, 4, 3, 2, 1])

>>> x[np.array([True, False, True, False, False])]

array([5, 3])

>>> x[[True, False, True, False, False]]

array([4, 5, 4, 5, 5])

>>> x[np.array([True, False, True, True])] = -1, -2, -3   # 布尔数组下标也可以用来修改元素

>>> x

array([-1, 4, -2, -3, 1])

>>> x = np.random.rand(10) # 产生一个长度为10，元素值为0-1的随机数的数组

>>> x

array([ 0.72223939, 0.921226 , 0.7770805 , 0.2055047 , 0.17567449,0.95799412, 0.12015178, 0.7627083 , 0.43260184, 0.91379859])

>>> x>0.5  # 数组x中的每个元素和0.5进行大小比较，得到一个布尔数组，True表示x中对应的值大于0.5

array([ True, True, True, False, False, True, False, True, False, True], dtype=bool)

>>> x[x>0.5]   # 使用x>0.5返回的布尔数组收集x中的元素，因此得到的结果是x中所有大于0.5的元素的数组

array([ 0.72223939, 0.921226 , 0.7770805 , 0.95799412, 0.7627083 ,0.91379859])

7)文件存取

NumPy提供了多种文件操作函数方便我们存取数组内容。文件存取的格式分为两类：二进制和文本。

而二进制格式的文件又分为NumPy专用的格式化二进制类型和无格式类型。

使用数组的方法函数tofile可以方便地将数组中数据以二进制的格式写进文件。tofile输出的数据没有格

式，因此用numpy.fromfile读回来的时候需要自己格式化数据：

>>> a = np.arange(0,12)

>>> a.shape = 3,4

>>> a

array([[ 0, 1, 2, 3],

[ 4, 5, 6, 7],

[ 8, 9, 10, 11]])

>>> a.tofile("a.bin")

>>> b = np.fromfile("a.bin", dtype=np.float) # 按照float类型读入数据

>>> b # 读入的数据是错误的

array([ 2.12199579e-314, 6.36598737e-314, 1.06099790e-313,

1.48539705e-313, 1.90979621e-313, 2.33419537e-313])

>>> a.dtype # 查看a的dtype

dtype('int32')

>>> b = np.fromfile("a.bin", dtype=np.int32) # 按照int32类型读入数据

>>> b # 数据是一维的

array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])

>>> b.shape = 3, 4 # 按照a的shape修改b的shape

>>> b # 这次终于正确了

array([[ 0, 1, 2, 3],

[ 4, 5, 6, 7],

[ 8, 9, 10, 11]])

>>> np.save("a.npy", a)

>>> c = np.load( "a.npy" )

>>> c

array([[ 0, 1, 2, 3],

[ 4, 5, 6, 7],

[ 8, 9, 10, 11]])

>>> a = np.array([[1,2,3],[4,5,6]])

>>> b = np.arange(0, 1.0, 0.1)

>>> c = np.sin(b)

>>> np.savez("result.npz", a, b, sin_array = c)

>>> r = np.load("result.npz")

>>> r["arr_0"] # 数组a

array([[1, 2, 3],

[4, 5, 6]])

>>> r["arr_1"] # 数组b

array([ 0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])

>>> r["sin_array"] # 数组c

array([ 0. , 0.09983342, 0.19866933, 0.29552021, 0.38941834,

0.47942554, 0.56464247, 0.64421769, 0.71735609, 0.78332691])

使用numpy.savetxt和numpy.loadtxt可以读写1维和2维的数组：

>>> a = np.arange(0,12,0.5).reshape(4,-1)

>>> np.savetxt("a.txt", a) # 缺省按照'%.18e'格式保存数据，以空格分隔

>>> np.loadtxt("a.txt")

array([[ 0. , 0.5, 1. , 1.5, 2. , 2.5],

[ 3. , 3.5, 4. , 4.5, 5. , 5.5],

[ 6. , 6.5, 7. , 7.5, 8. , 8.5],

[ 9. , 9.5, 10. , 10.5, 11. , 11.5]])

>>> np.savetxt("a.txt", a, fmt="%d", delimiter=",") #改为保存为整数，以逗号分隔

>>> np.loadtxt("a.txt",delimiter=",") # 读入的时候也需要指定逗号分隔

array([[ 0., 0., 1., 1., 2., 2.],

[ 3., 3., 4., 4., 5., 5.],

[ 6., 6., 7., 7., 8., 8.],

[ 9., 9., 10., 10., 11., 11.]])

2.4.

本节介绍所举的例子都是传递的文件名，也可以传递已经打开的文件对象，例如对于load和save

函数来说，如果使用文件对象的话，可以将多个数组储存到一个npy文件中：

>>> a = np.arange(8)

>>> b = np.add.accumulate(a)

>>> c = a + b

>>> f = file("result.npy", "wb")

>>> np.save(f, a) # 顺序将a,b,c保存进文件对象f

>>> np.save(f, b)

>>> np.save(f, c)

>>> f.close()

>>> f = file("result.npy", "rb")

>>> np.load(f) # 顺序从文件对象f中读取内容

array([0, 1, 2, 3, 4, 5, 6, 7])

>>> np.load(f)

array([ 0, 1, 3, 6, 10, 15, 21, 28])

>>> np.load(f)

array([ 0, 2, 5, 9, 14, 20, 27, 35])

函数 描述

abs(x ) 绝对值

divmod(x ,y ) 返回 (int(x / y ), x % y )

pow(x ,y [,modulo ]) 返回 (x ** y ) x % modulo

round(x ,[n]) 四舍五入，n为小数点位数math.ceil(),math.floor(),都可以舍去小数。>>> divmod(10,3)

(3, 1)

>>> divmod(3,10)

(0, 3)

>>> divmod(10,2.5)

(4.0, 0.0)

>>> divmod(2.5,10)

(0.0, 2.5)

>>> divmod(2+1j, 0.5-1j)

(0j, (2+1j))

进行浮点数运算时，结果不能等于0，否则会出现运算错误，需要引入decimal()处理。

import decimal

decimal.Decimal('0.1+0.1')-decimal.Decimal('0.2')

abs()函数返回一个数的绝对值。divmod()函数返回一个包含商和余数的元组。pow()函数可以用于代替 ** 运算，但它还支持三重取模运算(经常用于密码运算)。 round函数总是返回一个浮点数。

下列比较操作有标准的数学解释,返回一个布尔值True,或者False:运算符 描述

x < y 小于

x > y 大于

x == y 等于

x != y 不等于(与<>相同)

x >= y 大于等于

x <= y 小于等于

Python的比较运算可以连结在一起，如w < x < y < z 。这个表达式等价于 w < x and x < y and y < z 。

x < y > z这个表达式也是合法的，(注意,这个表达式中 x 和 z 并没有比较操作)。不建议这样的写法，因为这会造成代码的阅读困难。

只可以对复数进行等于(==)及不等于(!=)比较，任何对复数进行其他比较的操作都会引发TypeError异常。

数值操作要求操作数必须是同一类型，若Python发现操作数类型不一致，就会自动进行类型的强制转换，转换规则如下:1.如果操作数中有一个是复数，另一个也将被转换为复数

2.如果操作数中有一个是浮点数，另一个将被转换为浮点数

3.如果操作数中有一个是长整数数，另一个将被转换为长整数数

4.如果以上都不符合，则这两个数字必然都是整数，不需进行强制转换。

min(s)                  最小元素

max(s)                  最大元素

字符 输出格式

d,i 十进制整数或长整数

u 无符号十进制整数或长整数

o 八进制整数或长整数

x 十六进制整数或长整数

X 十六进制整数或长整数(大写字母)

f 浮点数如 [-]m.dddddd

e 浮点数如 [-]m .dddddde ±xx .

E 浮点数如 [-]m .ddddddE ±xx .

g,G 指数小于-4或者更高精确度使用 %e 或 %E; 否则,使用 %f

s 字符串或其他对象,使用str()来产生字符串

r 与 repr() 返回的字符串相同

c 单个字符

% 转换符标识 %

在 % 和转换字符串之间,允许出现以下修饰符,并且只能按以下顺序:1.映射对象的 key,如果被格式化对象是一个映射对象却没有这个成分,会引发KeyError异常.

2.下面所列的一个或多个:

左对齐标志

+,数值指示必须包含

0,指示一个零填充

3.指示最小栏宽的数字.转换值会被打印在指定了最小宽度的栏中并且填充在(或者右边).

4. 一个小数点用来分割浮点数

5. A number specifying the maximum number of characters to be printed from a string, the number of digits following the decimal point in a floating-point number, or the minimum number of digits for an integer.

另外,形标(*)字符用于在任意宽度的栏中代替数字. If present, the width will be read from the next item in the tuple.下边的代码给出了几个例子:

Toggle line numbers1a = 422b = 13.1427833c = "hello"4d = {'x':13, 'y':1.54321, 'z':'world'}5e = 5628398123741234L67print'a is%d' % a#  "a is 42"8print'%10d%f' % (a,b)         #  " 42 13.142783"9print'%+010d%E' % (a,b)       #  "+000000042 1.314278E+01"10print'%(x)-10d%(y)0.3g' % d#  "13         1.54"11print'%0.4s%s' % (c, d['z'])  #  "hell world"12print'%*.*f' % (5,3,b)         #  "13.143"13print'e =%d' % e#  "e = 5628398123741234"

简单的画图：

matplotlib 是python最著名的绘图库，它提供了一整套和matlab相似的命令API，十分适合交互式地进行制图。而且也可以方便地将它作为绘图控件，嵌入GUI应用程序中。

plt.axis([0, 6, 0, 20])   限定区间范围x(0,6),y(0,20)

matplotlib的pyplot子库提供了和matlab类似的绘图API，方便用户快速绘制2D图表。

2 import numpy as np

3 import matplotlib.pyplot as plt

4

5 x = np.linspace(0, 10, 1000)

6 y = np.sin(x)

7 z = np.cos(x**2)

8

9 plt.figure(figsize=(8,4))

10 plt.plot(x,y,label="$sin(x)$",color="red",linewidth=2)

11 plt.plot(x,z,"b--",label="$cos(x^2)$")

12 plt.xlabel("Time(s)")

13 plt.ylabel("Volt")

14 plt.title("PyPlot First Example")

15 plt.ylim(-1.2,1.2)

16 plt.legend()   #右上角的标签，即写明x,y对应的曲线，与10，11行有关

17 plt.show()    #有它才能显示出图形

figsize():

通过figsize参数可以指定绘图对象的宽度和高度，单位为英寸；dpi参数指定绘图对象的分辨率，即每

英寸多少个像素，缺省值为80。因此本例中所创建的图表窗口的宽度为8*80 = 640像素。

绘制一组幂函数：

from matplotlib.matlab import *

x = linspace(-4, 4, 200)

f1 = power(10, x)

f2 = power(e, x)

f3 = power(2, x)

plot(x, f1, 'r',  x, f2, 'b', x, f3, 'g', linewidth=2)

axis([-4, 4, -0.5, 8])

text(1, 7.5, r'$10^x$', fontsize=16)

text(2.2, 7.5, r'$e^x$', fontsize=16)

text(3.2, 7.5, r'$2^x$', fonsize=16)

title('A simple example', fontsize=16)

savefig('asd.png', dpi=75)

show()

另一个例子：from matplotlib.matlab import *

def f(x, c):

m1 = sin(2*pi*x)

m2 = exp(-c*x)

return multiply(m1, m2)

x = linspace(0, 4, 100)

sigma = 0.5

plot(x, f(x, sigma), 'r', linewidth=2)

xlabel(r'$\rm{time} \ t$', fontsize=16)

ylabel(r'$\rm{Amplitude} \ f(x)$', fontsize=16)

title(r'$f(x) \ \rm{is \ damping \ with} \ x$', fontsize=16)

text(2.0, 0.5, r'$f(x) = \rm{sin}(2 \pi x^2) e^{\sigma x}$', fontsize=20)

savefig('latex.png', dpi=75)

show()

多轴图：subplot函数快速绘制有多个轴的图表。subplot函数的调用形式如下：

subplot(numRows, numCols, plotNum)

作用：创建子图，numRows表示整个大图要分的行数，即每列有几个图。numcols表示整个大图要分的列数，即每行

有几个图，plotnum表示子图在大图中占的位置，顺序为自左到右自上到下。

下面的程序创建3行2列共6个轴，通过axisbg参数给每个轴设置不同的背景颜色。

for idx, color in enumerate("rgbyck"):

plt.subplot(320+idx+1, axisbg=color)

plt.show()

一个图里分几个子图同时显示：

>>> def f(t):

return np.exp(-t)*np.cos(2*np.pi*t)

>>> t1 = np.arange(0.0,5.0,0.1)

>>> t2 = np.arange(0.0,5.0,0.02)

>>> plt.figure(1)

>>> plt.subplot(211)

>>> plt.plot(t1,f(t1),'bo',t2,f(t2),'k')

[, ]

>>> plt.subplot(212)

>>> plt.plot(t2,np.cos(2*np.pi*t2),'r--')

[]

>>> plt.show()

标题写箭头：plt.title('$\leftarrow$')

柱形图：

import numpy as np

import matplotlib.pyplot as plt

mu,sigma = 100,15

x = mu + sigma*np.random.randn(10000)

# the histogram of the data

n,bins,patches = plt.hist(x,50,normed=1,facecolor='g',alpha=0.75)

plt.xlabel('Smarts')

plt.ylabel('Probability')

plt.title('Histogram of IQ')

plt.text(60,.025,r'$\mu=100,\ \sigma=15$')

plt.axis([40,160,0,0.03])

plt.grid(True)

plt.show()

这个plt.hist(x,y)整死我了，用法和参数及表示的意思都没有地方所，就连官方网都只是一段代码和几个不明白的参数，这个函数的目的都没有写。研究了一半天就在我快要放弃的时候，我最终从数据看出来了。

最后感觉这个还真是比MATLAB更智能点。。不好看懂，因为有些数据它是直接计算再进行画图的。

y 是图片里所要分的区间数，X是要处理的数据。运行函数plt.hist(x,y)后，会显示两组数据。

第二组：是y+1个数组，首尾分别是X组中的最小的和最大的数，里面分成y段即y个区间，成员数据大小呈等差增加

第一组：X数组中的数据在每个区间分布的个数。

时间紧就不上图了