转载 论numpy中matrix 和 array的区别
Numpy mat必须是2维的,但是 numpy arrays (ndarrays) 可以是多维的(1D，2D，3D····ND). Matrix是Array的一个小的分支，包含于Array。所以matrix 拥有array的所有特性。
在numpy中matrix的主要优势是：相对简单的乘法运算符号。例如，a和b是两个matrices，那么a*b，就是矩阵积。
import numpy as np
import numpy as np
a=np.mat([[1,2], [3,4]])
b=np.mat([[5,6],[7,8]])
print(a)
print(b)
print(a*b)
输出
[[1 2]
[3 4]]
[[5 6]
[7 8]]
[[19 22]
[43 50]]
matrix 和 array 都可以通过objects后面加.T 得到其转置。但是 matrix objects 还可以在后面加 .H f得到共轭矩阵, 加 .I 得到逆矩阵。
相反的是在numpy里面arrays遵从逐个元素的运算，所以array：c 和d的cd运算相当于matlab里面的c.*d运算。
c=np.array([[4, 3], [2, 1]])
d=np.array([[1, 2], [3, 4]])
print(c*d)
# [[4 6]
#  [6 4]]
而矩阵相乘，则需要numpy里面的dot命令 :
print(np.dot(c,d))
# [[13 20]
#  [ 5  8]]
** 运算符的作用也不一样 ：
print(a**2)
# [[22 15]
#  [10  7]]
print(c**2)
# [[16  9]
#  [ 4  1]]
因为a是个matrix，所以a2返回的是aa，相当于矩阵相乘。而c是array，c*2相当于，c中的元素逐个求平方。
问题就出来了，如果一个程序里面既有matrix 又有array，会让人脑袋大。但是如果只用array，你不仅可以实现matrix所有的功能，还减少了编程和阅读的麻烦。
当然你可以通过下面的两条命令轻松的实现两者之间的转换：np.asmatrix和np.asarray

软链接和硬链接文件的区别:
1.软链接（符号链接）
    软链接又叫符号链接，这个文件包含了另一个文件的路径名。可以是任意文件或目录，可以链接不同文件系统的文件。
    软链接文件有点类似于Windows的快捷方式。它实际上是特殊文件的一种。在符号连接中，文件实际上是一个文本文件，其中包含的有另一文件的位置信息。
    链接文件甚至可以链接不存在的文件，这就产生一般称之为"断链"的问题(或曰“现象")，链接文件甚至可以循环链接自己。类似于编程语言中的递归。
    用ln -s 命令可以生成一个软连接，如: ln -s  source_file softlink_file
    在对符号文件进行读或写操作的时候，系统会自动把该操作转换为对源文件的操作，但删除链接文件时，系统仅仅删除链接文件，而不删除源文件本身。
2.硬链接
   硬连接指通过索引节点来进行的连接。在Linux的文件系统中，保存在磁盘分区中的文件不管是什么类型都给它分配一个编号，称为索引节点号(Inode Number)。

    在Linux中，多个文件名指向同一索引节点是存在的。一般这种连接就是硬连接。硬连接的作用是允许一个文件拥有多个有效路径名。这样用户就可以建立硬连接到重要文件,以防止“误删”的功能。其原因如上所述，因为对应该目录的索引节点有一个以上的连接。只删除一个连接并不影响索引节点本身和其它的连接，只有当最后一个连接被删除后，文件的数据块及目录的连接才会被释放。也就是说，文件才会被真正删除。
     硬连接的命令是：  ln -d existfile newfile

　　硬链接文件有两个限制

　　1)、不允许给目录创建硬链接；

　　2)、只有在同一文件系统中的文件之间才能创建硬链接。
 
总结：
硬连接记录的是目标的 inode,符号连接记录的是目标的 path。  

软连接就像是快捷方式,而硬连接就像是备份!符号连接可以做跨分区的 link；而 硬连接由于 inode 的缘故，只能在本分区中做 link.所以,符号连接的使用频率要高的多。
 

Numpy matrices必须是2维的,但是 numpy arrays (ndarrays) 可以是多维的（1D，2D，3D····ND）. Matrix是Array的一个小的分支，包含于Array。所以matrix 拥有array的所有特性。

在numpy中matrix的主要优势是：相对简单的乘法运算符号。例如，a和b是两个matrices，那么a*b，就是矩阵积。而不用np.dot()。如：



import numpy as np

a=np.mat('4 3; 2 1')
b=np.mat('1 2; 3 4')
print(a)
# [[4 3]
#  [2 1]]
print(b)
# [[1 2]
#  [3 4]]
print(a*b)
# [[13 20]
#  [ 5  8]]





 

 matrix 和 array 都可以通过objects后面加.T 得到其转置。但是 matrix objects 还可以在后面加 .H f得到共轭矩阵, 加 .I 得到逆矩阵。

相反的是在numpy里面arrays遵从逐个元素的运算，所以对于array：c 和d的c*d运算相当于matlab里面的c.*d运算。

 

c=np.array([[4, 3], [2, 1]])
d=np.array([[1, 2], [3, 4]])
print(c*d)
# [[4 6]
#  [6 4]]



 

而矩阵相乘，则需要numpy里面的dot命令 :

print(np.dot(c,d))
# [[13 20]
#  [ 5  8]]



 但是python中矩阵没有MATLAB中的.*这个性质，对于matrix对应乘法得用np.multiply()

>>> np.multiply(a,b)
matrix([[ 4,  6],
                [6,  4]])   

 

当然 ** 运算符的作用也不一样 ：

print(a**2)  #矩阵乘法
# [[22 15]
#  [10  7]]
print(c**2)  #对应乘法
# [[16  9]
#  [ 4  1]]



问题就出来了，如果一个程序里面既有matrix 又有array，会让人脑袋大。但是如果只用array，你不仅可以实现matrix所有的功能，还减少了编程和阅读的麻烦。

当然你可以通过下面的两条命令轻松的实现两者之间的转换：np.asmatrix和np.asarray

对我来说，numpy 中的array与numpy中的matrix，matlab中的matrix的最大的不同是，在做归约运算时，array的维数会发生变化，但matrix总是保持为2维。例如下面求平均值的运算



>>> m = np.mat([[1,2],[2,3]])
>>> m
matrix([[1, 2],
        [2, 3]])
>>> mm = m.mean(1)
>>> mm
matrix([[ 1.5],
        [ 2.5]])
>>> mm.shape
(2, 1)
>>> m - mm
matrix([[-0.5,  0.5],
        [-0.5,  0.5]])



对array 来说



>>> a = np.array([[1,2],[2,3]])
>>> a
array([[1, 2],
       [2, 3]])
>>> am = a.mean(1)
>>> am.shape
(2,)
>>> am
array([ 1.5,  2.5])
>>> a - am #wrong
array([[-0.5, -0.5],
       [ 0.5,  0.5]])
>>> a - am[:, np.newaxis]  #right
array([[-0.5,  0.5],
       [-0.5,  0.5]])





转自：https://www.cnblogs.com/cymwill/p/7823148.html

%与fmod()在计算余数时的区别与联系
 
一、% 运算符

% 只用于整型的计算，后一个数不能是0，参与运算的数据可正可负。
对于x%y ，计算之后结果的正负与x的符号相同，如果前者是较小的数，后者是较大的数，那么，结果直接为较小的数。
 
例如：
10%3＝1
3%10＝3
10%-3＝1
-3%10＝-3
-10%-3＝-1
-3%-10＝-3
3%13＝3
0%3＝0
0%-3＝0
3%0  (×)Error!
-3%0  (×)Error!
10.0%3.0 (×)Error!浮点型不能进行模运算
 
 
 
二、fmod()函数

fmod()函数包含于math.h头文件中，它可以对浮点型数据进行取模运算
这是它的原型 double fmod(double x,double y)
fmod()函数没有%那样的要求，后一个数可为0，这时函数返回NaN
当参数为小数是，会进行如下运算：
返回值 ＝ x-n×y
 其中n＝x÷y ，并向离开0的方向取整
计算后结果的符号与前者(x)相同，如果前者是较小的数，后者是较大的数，那么结果直接为较小的数。
 
 

例如：
 
 
 float x=10.0;
 float y=-3.0;
 float z=3.0;



 result=fmod(x,z);   //应用 double fmod(double x,double y) 求浮点型的余数
 printf("10.0%%3.0= %f/n",result); //1.0



 result=fmod(z,x);
 printf("3.0%%10.0= %f/n",result); //3.0



 result=fmod(x,y);
 printf("10.0%%-3.0= %f/n",result); //1.0



 result=fmod(y,x);
 printf("-3.0%%10.0= %f/n",result); //-3.0



 result=fmod(0,z);
 printf("0.0%%3.0= %f/n",result); //0.0



 result=fmod(0,y);
 printf("0.0%%-3.0= %f/n",result); //0.0




 result=fmod(3,13);
 printf("3%%-13= %f/n",result);  //3


 result=fmod(10.1,3.1);
 printf("10.1%%3.1= %f/n",result); //0.8



 result=fmod(10.9,3.9);
 printf("10.9%%3.9= %f/n",result); //3.1




 result=fmod(10.9,-3.9);
 printf("10.9%%-3.9= %f/n",result); //3.1



 result=fmod(-10.9,3.9);
 printf("-10.9%%3.9= %f/n",result); //-3.1



 result=fmod(-10.9,-3.9);
 printf("-10.9%%-3.9= %f/n",result); //-3.1




 result=fmod(-10.9,12);
 printf("-10.9%%12= %f/n",result); //-10.9

 

 
by Nista 2010-09-24