[python]科学计算

zhangpengfei00

　　麻烦转载的朋友，请标明出处，作者，让我也小小虚荣一下。。。这都是我花了好多时间整理出来的。
　　谢谢各位捧场。。。
　　进行命令行，输入 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>Toggle line numbers   1 a = 42   2 b = 13.142783   3 c = "hello"   4 d = {'x':13, 'y':1.54321, 'z':'world'}   5 e = 5628398123741234L   6    7 print'a is %d' % a#  "a is 42"   8 print'%10d%f' % (a,b)         #  " 42 13.142783"   9 print'%+010d%E' % (a,b)       #  "+000000042 1.314278E+01"  10 print'%(x)-10d%(y)0.3g' % d#  "13         1.54"  11 print'%0.4s%s' % (c, d['z'])  #  "hell world"  12 print'%*.*f' % (5,3,b)         #  "13.143"  13 print'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>　　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)
　　<matplotlib.figure.Figure object at 0x0433FF50>
　　>>> plt.subplot(211)
　　<matplotlib.axes.AxesSubplot object at 0x02700830>
　　>>> plt.plot(t1,f(t1),'bo',t2,f(t2),'k')
　　[<matplotlib.lines.Line2D object at 0x04463310>, <matplotlib.lines.Line2D object at 0x0447E570>]
　　>>> plt.subplot(212)
　　<matplotlib.axes.AxesSubplot object at 0x0447E450>
　　>>> plt.plot(t2,np.cos(2*np.pi*t2),'r--')
　　[<matplotlib.lines.Line2D object at 0x04530510>]
　　>>> 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数组中的数据在每个区间分布的个数。
　　时间紧就不上图了