python中和差积商的缩写_Python科学计算基础篇

最新推荐文章于 2021-05-24 13:31:29 发布

weixin_39666931

最新推荐文章于 2021-05-24 13:31:29 发布

阅读量782

点赞数

文章标签： python中和差积商的缩写

本文链接：https://blog.csdn.net/weixin_39666931/article/details/111864688

版权

关于Numpy

Numpy是Python的一个矩阵类型，提供大量矩阵处理函数，内部通过C实现。

包含两种数据结构，数组array和矩阵matrix，其实就是array而已

构建数组array

通过tuple构建array

In[1]: from numpy import *

In[2]: yuanzu = (4,5,6)

In[3]: ll = array(yuanzu)

In[4]: ll

Out[4]: array([4, 5, 6])

通过list构建array

In[5]: pylist = [0,1,2]

In[6]: jj = array(pylist)

In[7]: jj

Out[7]: array([0, 1, 2])

构建多维array

In[95]: pylist1 = [1,2,3]

In[96]: pylist2 = [4,5,6]

In[100]: marray = array([pylist1,pylist2])

In[102]: marray

Out[102]:

array([[1, 2, 3],

[4, 5, 6]])

array基本操作

以marray的array来说

In[102]: marray

Out[102]:

array([[1, 2, 3],

[4, 5, 6]])

array索引

In[104]: marray[0][2]

Out[104]: 3

array的对应相乘

In[105]: marray*2

Out[105]:

array([[ 2, 4, 6],

[ 8, 10, 12]])

In[106]: marray*marray

Out[106]:

array([[ 1, 4, 9],

[16, 25, 36]])

构建矩阵matrix

同样可由tuple和list构建matrix

#由list构建

In[84]: mm = mat(pylist)

In[85]: mm

Out[85]: matrix([[0, 1, 2]])

#由tuple构建

In[107]: oo = mat(yuanzu)

In[108]: oo

Out[108]: matrix([[4, 5, 6]])

由array构建matrix

In[109]: pp = mat(marray)

In[110]: pp

Out[110]:

matrix([[1, 2, 3],

[4, 5, 6]])

matrix基本操作

对下面的pp矩阵来操作

In[110]: pp

Out[110]:

matrix([[1, 2, 3],

[4, 5, 6]])

查看维数.shape

In[111]: pp.shape

Out[111]: (2L, 3L) #两行三列的矩阵

取值，可以使用分片方法

In[116]: pp[1,2] #取第二行第三列元素

Out[116]: 6

In[115]: pp[1,:] #取第二行，所有列

Out[115]: matrix([[4, 5, 6]])

转置.T

In[112]: pp.T

Out[112]:

matrix([[1, 4],

[2, 5],

[3, 6]])

矩阵乘法，注意矩阵乘法的规则，(m,n)*(n,p)，对应维数。

In[113]: pp*(pp.T)

Out[113]:

matrix([[14, 32],

[32, 77]])

对应元素相乘 multiply(a,b)

In[114]: multiply(pp,pp)

Out[114]:

matrix([[ 1, 4, 9],

[16, 25, 36]])

排序sort，注意是原地排序，会改变原始数据，这个和pandas中的index操作不一样

In[119]: qq = mat([2,1,3]) #构建一个新的matrix

In[120]: qq

Out[120]: matrix([[2, 1, 3]])

In[121]: qq.sort() #进行递增排序，改变原来数据

In[122]: qq

Out[122]: matrix([[1, 2, 3]])

获得矩阵中每个元素的排序序号

In[126]: cc = mat([[3,1,4],[2,3,4]]) #重新构建一个矩阵

In[127]: cc

Out[127]:

matrix([[3, 1, 4],

[2, 3, 4]])

In[128]: cc.argsort()

Out[128]:

matrix([[1, 0, 2],

[0, 1, 2]], dtype=int64)

#比如说[3,1,4]这一行，元素先从小到大排序为[1,3,4]，对应1的元素在原本的矩阵中索引应该是1，对应3的索引是0，4的索引是2，所以得出[1,0,2]

array VS matrix

官方建议多使用array

The main advantage of numpy arrays is that they are more general than 2-dimensional matrices. What happens when you want a 3-dimensional array? Then you have to use an ndarray, not a matrix object. Thus, learning to use matrix objects is more work -- you have to learn matrix object operations, and ndarray operations.

一句话，matrix应该算是array的一个分支，只是array的二维表示而已，matrix的操作，array都可以完成，值得注意的是，想要完成矩阵相乘，而不是对应相乘，array需要采用dot方法，举个例子

#对应相乘

In[129]: marray*marray

Out[129]:

array([[ 1, 4, 9],

[16, 25, 36]])

#矩阵相乘

In[130]: marray.dot(marray.T)

Out[130]:

array([[14, 32],

[32, 77]])

总结

If you are willing to give up the visual appeal of numpy matrix product notation, then I think numpy arrays are definitely the way to go.

--也就是，没事多用用array

来源：http://blog.csdn.net/lsjseu/article/details/20359201

用Python做科学计算：基础篇、手册篇、实战篇：http://old.sebug.net/paper/books/scipydoc/index.html

先决条件

在阅读这个教程之前，你多少需要知道点Python。如果你想从新回忆下，请看看Python Tutorial.

如果你想要运行教程中的示例，你至少需要在你的电脑上安装了以下一些软件:

Python

NumPy

这些是可能对你有帮助的:

ipython是一个净强化的交互Python Shell，对探索NumPy的特性非常方便。

matplotlib将允许你绘图

Scipy在NumPy的基础上提供了很多科学模块

基础篇

NumPy的主要对象是同种元素的多维数组。这是一个所有的元素都是一种类型、通过一个正整数元组索引的元素表格(通常是元素是数字)。在NumPy中维度(dimensions)叫做轴(axes)，轴的个数叫做秩(rank)。

例如，在3D空间一个点的坐标[1, 2, 3]是一个秩为1的数组，因为它只有一个轴。那个轴长度为3.又例如，在以下例子中，数组的秩为2(它有两个维度).第一个维度长度为2,第二个维度长度为3.

[[ 1., 0., 0.],

[ 0., 1., 2.]]

NumPy的数组类被称作ndarray。通常被称作数组。注意numpy.array和标准Python库类array.array并不相同，后者只处理一维数组和提供少量功能。更多重要ndarray对象属性有：

ndarray.ndim

数组轴的个数，在python的世界中，轴的个数被称作秩

ndarray.shape

数组的维度。这是一个指示数组在每个维度上大小的整数元组。例如一个n排m列的矩阵，它的shape属性将是(2,3),这个元组的长度显然是秩，即维度或者ndim属性

ndarray.size

数组元素的总个数，等于shape属性中元组元素的乘积。

ndarray.dtype

一个用来描述数组中元素类型的对象，可以通过创造或指定dtype使用标准Python类型。另外NumPy提供它自己的数据类型。

ndarray.itemsize

数组中每个元素的字节大小。例如，一个元素类型为float64的数组itemsiz属性值为8(=64/8),又如，一个元素类型为complex32的数组item属性为4(=32/8).

ndarray.data

包含实际数组元素的缓冲区，通常我们不需要使用这个属性，因为我们总是通过索引来使用数组中的元素。

一个例子1

>>> from numpy import *

>>> a = arange(15).reshape(3, 5)

>>> a

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

[ 5, 6, 7, 8, 9],

[10, 11, 12, 13, 14]])

>>> a.shape

(3, 5)

>>> a.ndim

>>> a.dtype.name

'int32'

>>> a.itemsize

>>> a.size

>>> type(a)

numpy.ndarray

>>> b = array([6, 7, 8])

>>> b

array([6, 7, 8])

>>> type(b)

numpy.ndarray

创建数组

有好几种创建数组的方法。

例如，你可以使用array函数从常规的Python列表和元组创造数组。所创建的数组类型由原序列中的元素类型推导而来。

>>> from numpy import *

>>> a = array( [2,3,4] )

>>> a

array([2, 3, 4])

>>> a.dtype

dtype('int32')

>>> b = array([1.2, 3.5, 5.1])

>>> b.dtype

dtype('float64') 一个常见的错误包括用多个数值参数调用`array`而不是提供一个由数值组成的列表作为一个参数。

>>> a = array(1,2,3,4) # WRONG

>>> a = array([1,2,3,4]) # RIGHT

数组将序列包含序列转化成二维的数组，序列包含序列包含序列转化成三维数组等等。

>>> b = array( [ (1.5,2,3), (4,5,6) ] )

>>> b

array([[ 1.5, 2. , 3. ],

[ 4. , 5. , 6. ]])

数组类型可以在创建时显示指定

>>> c = array( [ [1,2], [3,4] ], dtype=complex )

>>> c

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

[ 3.+0.j, 4.+0.j]])

通常，数组的元素开始都是未知的，但是它的大小已知。因此，NumPy提供了一些使用占位符创建数组的函数。这最小化了扩展数组的需要和高昂的运算代价。

函数function创建一个全是0的数组，函数ones创建一个全1的数组，函数empty创建一个内容随机并且依赖与内存状态的数组。默认创建的数组类型(dtype)都是float64。

>>> zeros( (3,4) )

array([[0., 0., 0., 0.],

[0., 0., 0., 0.],

[0., 0., 0., 0.]])

>>> ones( (2,3,4), dtype=int16 ) # dtype can also be specified

array([[[ 1, 1, 1, 1],

[ 1, 1, 1, 1],

[ 1, 1, 1, 1]],

[[ 1, 1, 1, 1],

[ 1, 1, 1, 1],

[ 1, 1, 1, 1]]], dtype=int16)

>>> empty( (2,3) )

array([[ 3.73603959e-262, 6.02658058e-154, 6.55490914e-260],

[ 5.30498948e-313, 3.14673309e-307, 1.00000000e+000]])

为了创建一个数列，NumPy提供一个类似arange的函数返回数组而不是列表:

>>> arange( 10, 30, 5 )

array([10, 15, 20, 25])

>>> arange( 0, 2, 0.3 ) # it accepts float arguments

array([ 0. , 0.3, 0.6, 0.9, 1.2, 1.5, 1.8])

当arange使用浮点数参数时，由于有限的浮点数精度，通常无法预测获得的元素个数。因此，最好使用函数linspace去接收我们想要的元素个数来代替用range来指定步长。

其它函数array, zeros, zeros_like, ones, ones_like, empty, empty_like, arange, linspace, rand, randn, fromfunction, fromfile参考：NumPy示例

打印数组

当你打印一个数组，NumPy以类似嵌套列表的形式显示它，但是呈以下布局：

最后的轴从左到右打印

次后的轴从顶向下打印

剩下的轴从顶向下打印，每个切片通过一个空行与下一个隔开

一维数组被打印成行，二维数组成矩阵，三维数组成矩阵列表。

>>> a = arange(6) # 1d array

>>> print a

[0 1 2 3 4 5]

>>>

>>> b = arange(12).reshape(4,3) # 2d array

>>> print b

[[ 0 1 2]

[ 3 4 5]

[ 6 7 8]

[ 9 10 11]]

>>>

>>> c = arange(24).reshape(2,3,4) # 3d array

>>> print c

[[[ 0 1 2 3]

[ 4 5 6 7]

[ 8 9 10 11]]

[[12 13 14 15]

[16 17 18 19]

[20 21 22 23]]]

查看形状操作一节获得有关reshape的更多细节

如果一个数组用来打印太大了，NumPy自动省略中间部分而只打印角落

>>> print arange(10000)

[ 0 1 2 ..., 9997 9998 9999]

>>>

>>> print arange(10000).reshape(100,100)

[[ 0 1 2 ..., 97 98 99]

[ 100 101 102 ..., 197 198 199]

[ 200 201 202 ..., 297 298 299]

...,

[9700 9701 9702 ..., 9797 9798 9799]

[9800 9801 9802 ..., 9897 9898 9899]

[9900 9901 9902 ..., 9997 9998 9999]]

禁用NumPy的这种行为并强制打印整个数组，你可以设置printoptions参数来更改打印选项。

>>> set_printoptions(threshold='nan')

基本运算

数组的算术运算是按元素的。新的数组被创建并且被结果填充。

>>> a = array( [20,30,40,50] )

>>> b = arange( 4 )

>>> b

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

>>> c = a-b

>>> c

array([20, 29, 38, 47])

>>> b**2

array([0, 1, 4, 9])

>>> 10*sin(a)

array([ 9.12945251, -9.88031624, 7.4511316 , -2.62374854])

>>> a<35

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

不像许多矩阵语言，NumPy中的乘法运算符*指示按元素计算，矩阵乘法可以使用dot函数或创建矩阵对象实现(参见教程中的矩阵章节)

>>> A = array( [[1,1],

... [0,1]] )

>>> B = array( [[2,0],

... [3,4]] )

>>> A*B # elementwise product

array([[2, 0],

[0, 4]])

>>> dot(A,B) # matrix product

array([[5, 4],

[3, 4]])

有些操作符像+=和*=被用来更改已存在数组而不创建一个新的数组。

>>> a = ones((2,3), dtype=int)

>>> b = random.random((2,3))

>>> a *= 3

>>> a

array([[3, 3, 3],

[3, 3, 3]])

>>> b += a

>>> b

array([[ 3.69092703, 3.8324276 , 3.0114541 ],

[ 3.18679111, 3.3039349 , 3.37600289]])

>>> a += b # b is converted to integer type

>>> a

array([[6, 6, 6],

[6, 6, 6]])

当运算的是不同类型的数组时，结果数组和更普遍和精确的已知(这种行为叫做upcast)。

>>> a = ones(3, dtype=int32)

>>> b = linspace(0,pi,3)

>>> b.dtype.name

'float64'

>>> c = a+b

>>> c

array([ 1. , 2.57079633, 4.14159265])

>>> c.dtype.name

'float64'

>>> d = exp(c*1j)

>>> d

array([ 0.54030231+0.84147098j, -0.84147098+0.54030231j,

-0.54030231-0.84147098j])

>>> d.dtype.name

'complex128' 许多非数组运算，如计算数组所有元素之和，被作为ndarray类的方法实现

>>> a = random.random((2,3))

>>> a

array([[ 0.6903007 , 0.39168346, 0.16524769],

[ 0.48819875, 0.77188505, 0.94792155]])

>>> a.sum()

3.4552372100521485

>>> a.min()

0.16524768654743593

>>> a.max()

0.9479215542670073

这些运算默认应用到数组好像它就是一个数字组成的列表，无关数组的形状。然而，指定axis参数你可以吧运算应用到数组指定的轴上：

>>> b = arange(12).reshape(3,4)

>>> b

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

[ 4, 5, 6, 7],

[ 8, 9, 10, 11]])

>>>

>>> b.sum(axis=0) # sum of each column

array([12, 15, 18, 21])

>>>

>>> b.min(axis=1) # min of each row

array([0, 4, 8])

>>>

>>> b.cumsum(axis=1) # cumulative sum along each row

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

[ 4, 9, 15, 22],

[ 8, 17, 27, 38]])

通用函数(ufunc)

NumPy提供常见的数学函数如sin,cos和exp。在NumPy中，这些叫作“通用函数”(ufunc)。在NumPy里这些函数作用按数组的元素运算，产生一个数组作为输出。

>>> B = arange(3)

>>> B

array([0, 1, 2])

>>> exp(B)

array([ 1. , 2.71828183, 7.3890561 ])

>>> sqrt(B)

array([ 0. , 1. , 1.41421356])

>>> C = array([2., -1., 4.])

>>> add(B, C)

array([ 2., 0., 6.])

更多函数all, alltrue, any, apply along axis, argmax, argmin, argsort, average, bincount, ceil, clip, conj, conjugate, corrcoef, cov, cross, cumprod, cumsum, diff, dot, floor, inner, inv, lexsort, max, maximum, mean, median, min, minimum, nonzero, outer, prod, re, round, sometrue, sort, std, sum, trace, transpose, var, vdot, vectorize, where 参见:NumPy示例

索引，切片和迭代

一维数组可以被索引、切片和迭代，就像列表和其它Python序列。

>>> a = arange(10)**3

>>> a

array([ 0, 1, 8, 27, 64, 125, 216, 343, 512, 729])

>>> a[2]

>>> a[2:5]

array([ 8, 27, 64])

>>> a[:6:2] = -1000 # equivalent to a[0:6:2] = -1000; from start to position 6, exclusive, set every 2nd element to -1000

>>> a

array([-1000, 1, -1000, 27, -1000, 125, 216, 343, 512, 729])

>>> a[ : :-1] # reversed a