opencv-python 学习前的准备——Numpy-python详细教程2

NumPy - 位操作

下面是 NumPy 包中可用的位操作函数。

1. bitwise_and 对数组元素执行位与操作
2. bitwise_or 对数组元素执行位或操作
3. invert 计算位非
4. left_shift 向左移动二进制表示的位
5. right_shift 向右移动二进制表示的位

bitwise_and 位与操作

通过np.bitwise_and()函数对输入数组中的整数的二进制表示的相应位执行位与运算。

笔记：
bitwise （计算机）逐位，按位
bin()函数用于将数字转换为二进制。如果将数字传递给该bin()函数，则它将返回该数字的二进制表示形式。
Python中的二进制数字以0b开头。该bin()函数的结果也以0b开头。不要对此感到困惑。

例子

import numpy as np 
print '13 和 17 的二进制形式：' 
a,b = 13,17 
print bin(a), bin(b) 
print '\n'  
 
print '13 和 17 的位与：' 
print np.bitwise_and(13, 17)

# 输出如下：
13 和 17 的二进制形式：
0b1101 0b10001
 
13 和 17 的位与：
1
'''
你可以使用下表验证此输出。 考虑下面的位与真值表。
A	B	AND
1	1	1
1	0	0
0	1	0
0	0	0
| | | 1 | 1 | 0 | 1 |
| --- | --- |
| AND |
| | 1 | 0 | 0 | 0 | 1 |
| result | 0 | 0 | 0 | 0 | 1 |
'''

bitwise_or 位或操作

通过np.bitwise_or()函数对输入数组中的整数的二进制表示的相应位执行位或运算。

例子

import numpy as np 
a,b = 13,17 
print '13 和 17 的二进制形式：' 
print bin(a), bin(b)  
 
print '13 和 17 的位或：' 
print np.bitwise_or(13, 17)
输出如下：

13 和 17 的二进制形式：
0b1101 0b10001
 
13 和 17 的位或：
29
你可以使用下表验证此输出。 考虑下面的位或真值表。
'''
A	B	OR
1	1	1
1	0	1
0	1	1
0	0	0
| | | 1 | 1 | 0 | 1 |
| --- | --- |
| OR |
| | 1 | 0 | 0 | 0 | 1 |
| result | 1 | 1 | 1 | 0 | 1 |
'''

invert 位非操作

此函数计算输入数组中整数的位非结果。 对于有符号整数，返回补码。
笔记：invert 使倒置，使反转；使（位置、顺序或关系）颠倒，使互换；转回；转位；求逆，求反

例子

import numpy as np 
 
print '13 的位反转，其中 ndarray 的 dtype 是 uint8：' 
print np.invert(np.array([13], dtype = np.uint8)) 
print '\n'  
# 比较 13 和 242 的二进制表示，我们发现了位的反转
 
print '13 的二进制表示：' 
print np.binary_repr(13, width = 8) 
print '\n'  
 
print '242 的二进制表示：' 
print np.binary_repr(242, width = 8)

# 输出如下： 
13 的位反转，其中 ndarray 的 dtype 是 uint8：
[242]
 
13 的二进制表示：
00001101
 
242 的二进制表示：
11110010

请注意，**np.binary_repr()**函数返回给定宽度中十进制数的二进制表示。
笔记：np.binary_repr()函数与 Python内置函数bin()函数 类似，都是返回二进制。区别有二，1是np.binary_repr()可以设置长度（不够长自动补0），2是bin()返回的二进制以0b开头，而np.binary_repr()则没有0b开头。

left_shift 按位左移（右侧补0）

numpy.left shift()函数将数组元素的二进制表示中的位向左移动到指定位置，右侧附加相等数量的 0。
笔记：shift （使）移动，（使）转移；（使）转换到（另一个人或另一事物）；计算机）移位；按（计算机键盘上的）Shift 键；

例如

import numpy as np 
 
print '将 10 左移两位：' 
print np.left_shift(10,2) 
print '\n'  
 
print '10 的二进制表示：' 
print np.binary_repr(10, width = 8) 
print '\n'  
 
print '40 的二进制表示：' 
print np.binary_repr(40, width = 8)  
#  '00001010' 中的两位移动到了左边，并在右边添加了两个 0。
输出如下：

将 10 左移两位：
40
 
10 的二进制表示：
00001010
 
40 的二进制表示：
00101000

right_shift 按位右移（左侧补0）

numpy.right_shift()函数将数组元素的二进制表示中的位向右移动到指定位置，左侧附加相等数量的 0。

import numpy as np 
 
print '将 40 右移两位：' 
print np.right_shift(40,2) 
print '\n'  
 
print '40 的二进制表示：' 
print np.binary_repr(40, width = 8) 
print '\n'  
 
print '10 的二进制表示：' 
print np.binary_repr(10, width = 8)  
#  '00001010' 中的两位移动到了右边，并在左边添加了两个 0。
输出如下：

将 40 右移两位：
10
 
40 的二进制表示：
00101000
 
10 的二进制表示：
00001010

NumPy - 字符串函数

以下函数用于对dtype为numpy.string_或numpy.unicode_的数组执行向量化字符串操作。 它们基于 Python 内置库中的标准字符串函数。

1. add() 返回两个 str或Unicode数组的逐个字符串连接
2. multiply() 返回按元素多重连接后的字符串
3. center() 返回给定字符串的副本，其中元素位于特定字符串的中央
4. capitalize() 返回给定字符串的副本，其中只有第一个字符串大写
5. title() 返回字符串或 Unicode 的按元素标题转换版本
6. lower() 返回一个数组，其元素转换为小写
7. upper() 返回一个数组，其元素转换为大写
8. split() 返回字符串中的单词列表，并使用分隔符来分割
9. splitlines() 返回元素中的行列表，以换行符分割
10. strip() 返回数组副本，其中元素移除了开头或者结尾处的特定字符
11. join() 返回一个字符串，它是序列中字符串的连接
12. replace() 返回字符串的副本，其中所有子字符串的出现位置都被新字符串取代
13. decode() 按元素调用str.decode
14. encode() 按元素调用str.encode

这些函数在字符数组类（numpy.char）中定义。 较旧的 Numarray 包包含chararray类。 numpy.char类中的上述函数在执行向量化字符串操作时非常有用。
笔记：
capitalize 用大写字母书写（或印刷），把……首字母大写；
strip 除去，撕掉（外皮或表层）；
字符串向量化：向量化的操作使我们不必担心数组的长度和维度，只需要关系操作功能，尤为强大的是，除了支持常用的字符串操作方法，还集成了正则表达式的大部分功能

numpy.char.add()

函数执行按元素的字符串连接。

import numpy as np 
print '连接两个字符串：' 
print np.char.add(['hello'],[' xyz']) 
print '\n'
 
print '连接示例：' 
print np.char.add(['hello', 'hi'],[' abc', ' xyz'])
输出如下：

连接两个字符串：
['hello xyz']
 
连接示例：
['hello abc' 'hi xyz']

numpy.char.multiply()

这个函数执行多重连接。即：重复多次。

import numpy as np 
print np.char.multiply('Hello ',3)
输出如下：

Hello Hello Hello 

numpy.char.center()

此函数返回所需宽度的数组，以便输入字符串位于中心，并使用fillchar在左侧和右侧进行填充。

import numpy as np 
# np.char.center(arr, width,fillchar) 
print np.char.center('hello', 20,fillchar = '*')
输出如下：

*******hello********
numpy.char.capitalize()
函数返回字符串的副本，其中第一个字母大写

 
import numpy as np 
print np.char.capitalize('hello world')
输出如下：

Hello world 

numpy.char.title()

返回输入字符串的按元素标题转换版本，其中每个单词的首字母都大写。

import numpy as np 
print np.char.title('hello how are you?')
输出如下：

Hello How Are You?

numpy.char.lower()

函数返回一个数组，其元素转换为小写。它对每个元素调用str.lower。

import numpy as np 
print np.char.lower(['HELLO','WORLD']) 
print np.char.lower('HELLO')
输出如下：

['hello' 'world']
hello

numpy.char.upper()

函数返回一个数组，其元素转换为大写。它对每个元素调用str.upper。

import numpy as np 
print np.char.upper('hello') 
print np.char.upper(['hello','world'])
输出如下：

HELLO
['HELLO' 'WORLD']

numpy.char.split()

此函数返回输入字符串中的单词列表。 默认情况下，空格用作分隔符。 否则，指定的分隔符字符用于分割字符串。

import numpy as np 
print np.char.split ('hello how are you?') 
print np.char.split ('TutorialsPoint,Hyderabad,Telangana', sep = ',')
输出如下：

['hello', 'how', 'are', 'you?']
['TutorialsPoint', 'Hyderabad', 'Telangana']

numpy.char.splitlines() 换行符分割

函数返回数组中元素的单词列表，以换行符分割。

import numpy as np 
print np.char.splitlines('hello\nhow are you?') 
print np.char.splitlines('hello\rhow are you?')
输出如下：

['hello', 'how are you?']
['hello', 'how are you?']

‘\n’，‘\r’，'\r\n’都会用作换行符。

numpy.char.strip()

函数返回数组的副本，其中元素移除了开头或结尾处的特定字符。

import numpy as np 
print np.char.strip('ashok arora','a') 
print np.char.strip(['arora','admin','java'],'a')
输出如下：

shok aror
['ror' 'dmin' 'jav']

numpy.char.join()

这个函数返回一个字符串，其中单个字符由特定的分隔符连接。

import numpy as np 
print np.char.join(':','dmy') 
print np.char.join([':','-'],['dmy','ymd'])
输出如下：
d:m:y
['d:m:y' 'y-m-d']

numpy.char.replace()

这个函数返回字符串副本，其中所有字符序列的出现位置都被另一个给定的字符序列取代。

import numpy as np 
print np.char.replace ('He is a good boy', 'is', 'was')
输出如下：

He was a good boy

numpy.char.decode() 解码

这个函数在给定的字符串中使用特定编码调用str.decode()。
笔记：原理？？

import numpy as np 
 
a = np.char.encode('hello', 'cp500')    # 编码
print a 
print np.char.decode(a,'cp500')			# 解码
输出如下：

\x88\x85\x93\x93\x96
hello

numpy.char.encode() 编码

此函数对数组中的每个元素调用str.encode函数。 默认编码是utf_8，可以使用标准 Python 库中的编解码器。

import numpy as np 
a = np.char.encode('hello', 'cp500') 
print a
输出如下：

\x88\x85\x93\x93\x96

NumPy - 算数函数

很容易理解的是，NumPy 包含大量的各种数学运算功能。 NumPy 提供标准的三角函数，算术运算的函数，复数处理函数等。

三角函数

NumPy 拥有标准的三角函数，它为弧度制单位的给定角度返回三角函数比值。

重温三角函数（T_T ,希望这次能记牢点）

哎，三角函数已经忘光了，借此回忆一下
锐角三角函数：

任意角三角函数：

• sin() 正弦函数

  • 数学表达式 sin，角的对边与弦的比值
  • 锐角三角函数：
    
  • 任意角三角函数
    

• cos() 余弦函数

  • 数学表达式cos, 角的邻边（非正对的边）与弦的比值

  • 锐角三角形
    

  • 任意角三角形
    

• tan() 正切函数

  • 数学表达式 tan, 角的对边与邻边的比值

  • 锐角三角形
    

  • 任意角三角形
    

• arcsin() 余割函数

  • 数学表达式csc，角的斜边（弦）与对边的比值，与sin()比值正相反，与sin()是倒数关系。正弦、余割是一对。

  • 锐角三角形
    

  • 任意角三角形
    

• arccos() 正割函数

  • 数学表达式sec，角的斜边（弦）与对边的比值，与cos()比值正相反，与cos()是倒数关系。余弦、正割是一对。

  • 锐角三角形
    

  • 任意角三角形
    

• arctan() 余切函数

  • 数学表达式cot，角的对边与邻边的比值，与tan()比值正相反，与tan()是倒数关系。正切、余切是一对。

  • 锐角三角形
    

  • 任意角三角形
    

正弦、余割是一对
余弦、正割是一对
正切、余切是一对

三角函数关系

1. 倒数关系
   
   
   

2. 商数关系
   
   

3. 平方关系
   
   
   

诱导公式

为了便于理解：因为180度 = π，所以π + alpha从二维坐标系上看，就终边旋转180度（逆时针）。跨度为2个象限，例如：1变3, 2变4…

公式3中 -alpha 与 +alpha 从坐标系的角度看，角度（2π - alpha）与角度alpha 的终边实际是基于X轴的对称关系。
公式4中 π - alpha 从坐标系的角度看，角度（π - alpha）与角度alpha 的终边实际是基于Y轴的对称关系。
公式5中 2π - alpha 从坐标系的角度看，角度（2π - alpha）与角度alpha 的终边实际是基于X轴的对称关系。

因此，-alpha 与 2π - alpha 对于 +alpha来说（公式3与公式5），变化是一样的。

1/2 π + alpha 角的终边增加了一个象限（从二维坐标系角度看），为不对称变化，1/2 π - alpha的本质是alpha的补角（正）。
3/2π + alpha 角的终边增加了两个象限（从二维坐标系角度看），为不对称变化，3/2π - alpha的本质是alpha的补角（负）。

和差角公式

和差化积公式

倍角公式

二倍角、三倍角、四倍…N倍角，用到再学习吧，不详述。

半角公式

万能公式

辅助角公式

正弦定理

余弦定理

傅里叶级数

言归正传，继续学习numpy三角函数

笔记：
注意 NumPy 的三角函数 , 单位是弧度。

因为，180度 = π，所以 角度转弧度: 弧度 = 角度 * np.pi / 180
np.pi 是 NumPy的属性 π。

示例 sin(), cos()

import numpy as np
a = np.array([0,30,45,60,90])      # 角度的列表
print  '不同角度的正弦值：'  
# 通过乘 pi/180 转化为弧度  
print np.sin(a*np.pi/180)  
print  '\n'  
print  '数组中角度的余弦值：'  
print np.cos(a*np.pi/180)  
print  '\n'  
print  '数组中角度的正切值：'  
print np.tan(a*np.pi/180)  

#输出如下：
不同角度的正弦值：                                                   
[ 0.    0.5    0.70710678  0.8660254   1.   ]                 
 
数组中角度的余弦值：                                         
[  1.00000000e+00   8.66025404e-01   7.07106781e-01   5.00000000e-01          
   6.12323400e-17]                                                            
 
数组中角度的正切值：                                            
[  0.00000000e+00   5.77350269e-01   1.00000000e+00   1.73205081e+00          
   1.63312394e+16]

arcsin，arccos，和arctan函数返回给定角度的sin，cos和tan的反三角函数。
这些函数的结果可以通过numpy.degrees()函数通过将弧度制转换为角度制来验证。

注意：numpy 角度转弧度没有专用函数，只能自己写（例如：a*np.pi/180），但是，弧度转换为角度是有专用函数numpy.degrees()，
degree 度，度数（温度，角度），程度，音阶

示例 arcsin，arccos，和arctan函数 以及 degrees函数

import numpy as np
a = np.array([0,30,45,60,90])  
print  '含有正弦值的数组：'
sin = np.sin(a*np.pi/180)  
print sin
print  '\n'  
print  '计算角度的反正弦，返回值以弧度为单位：'
inv = np.arcsin(sin)    # arcsin反正弦 即：余割csc
print inv
print  '\n'  
print  '通过转化为角度制来检查结果：'  
print np.degrees(inv)    # 弧度转为角度
print  '\n'  
print  'arccos 和 arctan 函数行为类似：'
cos = np.cos(a*np.pi/180)  # 余弦
print cos
print  '\n'  
print  '反余弦：'
inv = np.arccos(cos)       # arccos反余弦  即：正割sec
print inv
print  '\n'  
print  '角度制单位：'  
print np.degrees(inv)  
print  '\n'  
print  'tan 函数：'
tan = np.tan(a*np.pi/180)   # 正切
print tan
print  '\n'  
print  '反正切：'
inv = np.arctan(tan)        # arctan 反正切  即：余切cot
print inv
print  '\n'  
print  '角度制单位：'  
print np.degrees(inv)  

# 输出如下：
含有正弦值的数组：
[ 0.          0.5         0.70710678  0.8660254   1.        ]
 
计算角度的反正弦，返回值以弧度制为单位：
[ 0.          0.52359878  0.78539816  1.04719755  1.57079633]
 
通过转化为角度制来检查结果：
[  0.  30.  45.  60.  90.]
 
arccos 和 arctan 函数行为类似：
[  1.00000000e+00   8.66025404e-01   7.07106781e-01   5.00000000e-01          
   6.12323400e-17]
 
反余弦：
[ 0.          0.52359878  0.78539816  1.04719755  1.57079633]
 
角度制单位：
[  0.  30.  45.  60.  90.]
 
tan 函数：
[  0.00000000e+00   5.77350269e-01   1.00000000e+00   1.73205081e+00          
   1.63312394e+16]
 
反正切：
[ 0.          0.52359878  0.78539816  1.04719755  1.57079633]
 
角度制单位：
[  0.  30.  45.  60.  90.]

舍入函数

numpy.around()

这个函数返回四舍五入到所需精度的值。 该函数接受以下参数。

numpy.around(a,decimals)

其中：

1. a 输入数组
2. decimals 要舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置

示例 四舍五入

import numpy as np
a = np.array([1.0, 5.55,  123,  0.567,  25.532])  
print  '原数组：'  
print a
print  '\n'  
print  '舍入后：'  
print np.around(a)  
print np.around(a, decimals =  1)  
print np.around(a, decimals =  -1)  # decimals =  -1 四舍五入到个位
输出如下：

 
原数组：                                                          
[   1.       5.55   123.       0.567   25.532]
 
舍入后：                                                         
[   1.    6.   123.    1.   26. ]                                               
[   1.    5.6  123.    0.6  25.5]                                          
[   0.    10.  120.    0.   30. ]

numpy.floor()

此函数返回不大于输入参数的最大整数。 即标量x 的下限是最大的整数i ，使得i <= x。

注意在Python中，向下取整总是从 0 舍入。

示例 向下取整

import numpy as np
a = np.array([-1.7,  1.5,  -0.2,  0.6,  10])  
print  '提供的数组：'  
print a
print  '\n'  
print  '修改后的数组：'  
print np.floor(a)

# 输出如下： 
提供的数组：                                                            
[ -1.7   1.5  -0.2   0.6  10. ]
 
修改后的数组：                                                         
[ -2.   1.  -1.   0.  10.]   

笔记： np.floor() 遇到正数时，直接去除小数部分；遇到负数时，小数部分会向个位进位。
好好理解这句话：标量x 的下限是最大的整数 i ，使得i <= x

numpy.ceil()

ceil()函数返回输入值的上限，即，标量x的上限是最小的整数i ，使得i> = x。

示例 进一取正，或叫做向下取整

import numpy as np
a = np.array([-1.7,  1.5,  -0.2,  0.6,  10])  
print  '提供的数组：'  
print a
print  '\n'  
print  '修改后的数组：'  
print np.ceil(a)

# 输出如下： 
提供的数组：
[ -1.7   1.5  -0.2   0.6  10. ]
 
修改后的数组：
[ -1.   2.  -0.   1.  10.]

NumPy - 算数运算

用于执行算术运算（如add()，subtract()，multiply()和divide()）的输入数组必须具有相同的形状或符合数组广播规则。

• add()
• subtract()
• multiply()
• divide()

示例 数组操作 加减乘除

import numpy as np 
a = np.arange(9, dtype = np.float_).reshape(3,3)  
print  '第一个数组：'  
print a 
print  '\n'  
print  '第二个数组：' 
b = np.array([10,10,10])  
print b 
print  '\n'  
print  '两个数组相加：'  
print np.add(a,b)  
print  '\n'  
print  '两个数组相减：'  
print np.subtract(a,b)  
print  '\n'  
print  '两个数组相乘：'  
print np.multiply(a,b)  
print  '\n'  
print  '两个数组相除：'  
print np.divide(a,b)

#输出如下：
第一个数组：
[[ 0. 1. 2.]
 [ 3. 4. 5.]
 [ 6. 7. 8.]]
 
第二个数组：
[10 10 10]
 
两个数组相加：
[[ 10. 11. 12.]
 [ 13. 14. 15.]
 [ 16. 17. 18.]]
 
两个数组相减：
[[-10. -9. -8.]
 [ -7. -6. -5.]
 [ -4. -3. -2.]]
 
两个数组相乘：
[[ 0. 10. 20.]
 [ 30. 40. 50.]
 [ 60. 70. 80.]]
 
两个数组相除：
[[ 0. 0.1 0.2]
 [ 0.3 0.4 0.5]
 [ 0.6 0.7 0.8]]
 

示例

import numpy as np 
a = np.arange(9, dtype = np.float_).reshape(3,3)  
print  ('第一个数组：')  
print (a) 
print  ('\n')  
print  ('第二个数组：') 
b = np.array([1,2,10])  
print (b) 
print  ('\n')  
print  ('两个数组相加：')  
print (np.add(a,b))  
print  ('\n')  
print  ('两个数组相减：')  
print (np.subtract(a,b))  
print  ('\n')  
print  ('两个数组相乘：' ) 
print (np.multiply(a,b))  
print  ('\n')  
print  ('两个数组相除：')  
print (np.divide(a,b))

# 输出结果
第一个数组：
[[0. 1. 2.]
 [3. 4. 5.]
 [6. 7. 8.]]
第二个数组：
[ 1  2 10]
两个数组相加：
[[ 1.  3. 12.]
 [ 4.  6. 15.]
 [ 7.  9. 18.]]
两个数组相减：
[[-1. -1. -8.]
 [ 2.  2. -5.]
 [ 5.  5. -2.]]
两个数组相乘：
[[ 0.  2. 20.]
 [ 3.  8. 50.]
 [ 6. 14. 80.]]


两个数组相除：
[[0.  0.5 0.2]
 [3.  2.  0.5]
 [6.  3.5 0.8]]

笔记：
一维数组 加减乘除运算 二维数组时，一维数组怎么变化的？
通过示例，可以看到一维数组b [ 1 2 10] 先广播为3行3列的数组(展开如下)，然后与a(3*3)数组进行运算。

一维数组（矩阵）b [ 1  2 10] 的广播结果
[ [ 1  2 10]
 [ 1  2 10]
 [ 1  2 10] ]

一维数组b纵向排序，该如何广播呢？当然b纵向排序后，将是个二维数组。排序结果如下：

二维数组（矩阵）b 
[[ 1]
[ 2]
[10]]
b向3*3矩阵广播后
[[ 1 1 1]
[  2 2 2]
[ 10 10 10]]

由上例可以证明，一维数组b（也可以理解为1行N列）广播时，将复制原始的一维数组并扩展为多维数组，即按行复制，增加一维的长度，变为多维；
二维数组b(也可以理解为N行1列)广播时，一维长度不变，复制二维项并增加二维长度，使其扩展到目标二维长度。

行列的概念用于理解二维比较方便，但是多于二维时并不便于理解甚至容易混淆，因此要明确其使用范围。

让我们现在来讨论 NumPy 中提供的一些其他重要的算术函数。

numpy.reciprocal() 求倒数

此函数返回参数逐元素的倒数。 x 的倒数为 1/x
由于 Python 处理整数除法的方式，对于绝对值大于 1 的整数元素，结果始终为 0， 对于整数 0，则发出溢出警告。

示例 x求倒数1/x

import numpy as np 
a = np.array([0.25,  1.33,  1,  0,  100])  
print  '我们的数组是：'  
print a 
print  '\n'  
print  '调用 reciprocal 函数：'  
print np.reciprocal(a)  
print  '\n' 
b = np.array([100], dtype =  int)    # 整数100 
print  '第二个数组：'  
print b 
print  '\n'  
print  '调用 reciprocal 函数：'  
print np.reciprocal(b)  			# 整数100的倒数，会被取整，其结果是0

# 输出如下：
我们的数组是：                                                               
[   0.25    1.33    1.      0.    100.  ]                                     
 
调用 reciprocal 函数：                                         
main.py:9: RuntimeWarning: divide by zero encountered in reciprocal           
  print np.reciprocal(a)                                                      
[ 4.         0.7518797  1.               inf  0.01     ]                      
 
第二个数组：                                                      
[100]                                                                         
 
调用 reciprocal 函数：                                        
[0]                         

笔记：inf符号的数学含义
inf，表示下确界，英文名infimum。
对于函数 y=f(x), 在使 f(x) 大于等于 M 成立的所有常数M中, 我们把M的最大值max(M) ( 即函数y=f(x)的最小值 ）叫做函数y=f(x)的下确界。
下确界: 在所有那些下界中如果有一个最大的下界, 就称之为M的下确界。

数学中inf是下界的意思。在数学实验中，存在一个实数a和一个实数集合B，使得对∀x∈B，都有x≥a，则称a为B的下界（lower bound）。相反，在数学中，特别是在秩序理论中，在某些部分有序集合（K，≤）的子集S里面，大于或等于S的每个元素的K的那个元素，叫做上界。而下界被定义为K的元素小于或等于S的每个元素。

numpy.power() 求幂

此函数将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂。

import numpy as np 
a = np.array([10,100,1000])  
print  '我们的数组是；'  
print a 
print  '\n'  
print  '调用 power 函数：'  
print np.power(a,2)  
print  '\n'  
print  '第二个数组：' 
b = np.array([1,2,3])  
print b 
print  '\n'  
print  '再次调用 power 函数：'  
print np.power(a,b)

# 输出如下：
我们的数组是；                                                              
[  10  100 1000]                                                              
 
调用 power 函数：                                                    
[  100   10000 1000000]                                                     
 
第二个数组：                                                              
[1 2 3]                                                                       
 
再次调用 power 函数：                                              
[  10  10000 1000000000] 

numpy.mod() 和 numpy.remainder() 求余数运算

此函数返回输入数组中相应元素的除法余数。
函数*numpy.remainder()*也产生相同的结果。
笔记：remainder 剩余部分，其余；廉价出售的书，滞销图书；差数，余数

import numpy as np 

a = np.array([10,20,30]) 
b = np.array([3,5,7])  
print  '第一个数组：'  
print a 
print  '\n'  
print  '第二个数组：'  
print b 
print  '\n' 
print  '调用 mod() 函数：'  
print np.mod(a,b)  
print  '\n'  
print  '调用 remainder() 函数：'  
print np.remainder(a,b)  

输出如下：

 
第一个数组：
[10 20 30]
 
第二个数组：
[3 5 7]
 
调用 mod() 函数：                                                     
[1 0 2]
 
调用 remainder() 函数：                                              
[1 0 2]

复数运算

以下函数用于对含有复数的数组执行操作。

• numpy.real() 返回复数类型参数的实部。
• numpy.imag() 返回复数类型参数的虚部。
• numpy.conj() 返回通过改变虚部的符号而获得的共轭复数。
• numpy.angle() 返回复数参数的角度。
  • 函数的参数是degree。 如果为true，返回的角度以角度制来表示，否则为以弧度制来表示。

import numpy as np 

a = np.array([-5.6j,  0.2j,  11.  ,  1+1j])  
print  '我们的数组是：'  
print a 
print  '\n'  
print  '调用 real() 函数：'  
print np.real(a)  
print  '\n'  
print  '调用 imag() 函数：'  
print np.imag(a)  
print  '\n'  
print  '调用 conj() 函数：'  
print np.conj(a)  
print  '\n'  
print  '调用 angle() 函数：'  
print np.angle(a)  
print  '\n'  
print  '再次调用 angle() 函数（以角度制返回）：'  
print np.angle(a, deg =  True)

# 输出如下：
我们的数组是：
[ 0.-5.6j 0.+0.2j 11.+0.j 1.+1.j ]
 
调用 real() 函数：
[ 0. 0. 11. 1.]
 
调用 imag() 函数：
[-5.6 0.2 0. 1. ]
 
调用 conj() 函数：
[ 0.+5.6j 0.-0.2j 11.-0.j 1.-1.j ]
 
调用 angle() 函数：
[-1.57079633 1.57079633 0. 0.78539816]
 
再次调用 angle() 函数（以角度制返回）：
[-90. 90. 0. 45.]

NumPy - 统计函数

NumPy 有很多有用的统计函数，用于从数组中给定的元素中查找最小，最大，百分标准差和方差等。 函数说明如下：

numpy.amin() 和 numpy.amax()

这些函数从给定数组中的元素沿指定轴返回最小值和最大值。

示例

import numpy as np 
a = np.array([[3,7,5],[8,4,3],[2,4,9]])  
print  '我们的数组是：'  
print a 
print  '\n'  
print  '调用 amin() 函数：'  
print np.amin(a,1)    # 沿第二轴查找最小值
print  '\n'  
print  '再次调用 amin() 函数：'  
print np.amin(a,0)    # 沿第一轴查找最小值
print  '\n'  
print  '调用 amax() 函数：'  
print np.amax(a)      # 无指定方向，全部元素内查找最大值
print  '\n'  
print  '再次调用 amax() 函数：'  
print np.amax(a, axis =  0)   # 指定方向0（第一维），查找最大值

# 输出如下：
我们的数组是：
[[3 7 5]
[8 4 3]
[2 4 9]]
 
调用 amin() 函数：   # 查询第二维查询最小值
[3 3 2]
 
再次调用 amin() 函数： # 查询第一维查询最小值
[2 4 3]
 
调用 amax() 函数：
9
 
再次调用 amax() 函数：
[8 7 9]

笔记： 对于numpy中轴的理解

对于numpy的函数中axis参数，一直比较糊涂。以上例来说，
[[3 7 5]
[8 4 3]
[2 4 9]]
axis = 0 表示第一维度，是否可以理解为宽度？
axis=1 表示第二维度，是否可以理解为高度？
不知是否应该这么理解，首先拜托宽度、高度的二维坐标系图像想象。只以数组形式进行理解，比如：

• axis=0时，第一维度，长度=3，元素项分别为 1=[3 7 5]；2=[8 4 3]；3=[2 4 9]
  沿0轴搜索方式，比较这3个元素项，又因为元素项内包含3个子项；所以，每个元素的对应序号子项进行操作。这么理解，可以得到预期的结果。

• axis=1时，第二维度，长度=3，元素项分别为 1=[3 8 2]; 2=[7 4 4]; 3=[5 3 9]
  沿1轴搜索方式，比较这3个元素项，原理同上

问题是如果是三维或者大于三维如何解释？
待续…

numpy.ptp() 返回范围，即：最大值 减去 最小值

numpy.ptp()函数返回沿轴的值的范围（最大值 减去 最小值）。
np.ptp()函数实现的功能等同于np.max(array) - np.min(array)

numpy.ptp(a, axis=None, out=None, keepdims=<no value>)

各个参数意义

• a：输入数组
• axis: 决定沿着哪一个轴寻找峰值位置，默认将数组扁平化以后寻找峰值位置，当然该值也可以为负数，表示从最后一个坐标轴向第一个坐标轴寻找峰值位置
  有返回值，返回值为一个元组类型的索引数组，即得到 非零元素在原数组中的下标
• out:输出数组，要求它必须具有相同的形状和缓冲区长度，所以一般来说可以不进行指定。(这里不做过多讨论)
• keepdims：(True or False，选填参数),
  有返回值，设定了out参数时可以将值返回到一个与out参数相关的数组中进行保存。如果没有设定，我们可以直接指将值返回到一个数组中。

import numpy as np 
a = np.array([[3,7,5],[8,4,3],[2,4,9]])  
print  '我们的数组是：'  
print a 
print  '\n'  
print  '调用 ptp() 函数：'  
print np.ptp(a)  
print  '\n'  
print  '沿轴 1 调用 ptp() 函数：'  
print np.ptp(a, axis =  1)  
print  '\n'  
print  '沿轴 0 调用 ptp() 函数：'  
print np.ptp(a, axis =  0)  

# 输出如下：
我们的数组是：
[[3 7 5]
[8 4 3]
[2 4 9]]
 
调用 np.ptp(a) 函数：
7
 
沿轴 1 调用 np.ptp(a, axis =  1)  函数：
[4 5 7]
 
沿轴 0 调用 np.ptp(a, axis =  0)  函数：
[6 3 6]

numpy.percentile()

百分位数是统计中使用的度量，表示小于这个值的观察值占某个百分比。

函数numpy.percentile()接受以下参数。

numpy.percentile(a, q, axis)

其中：

1. a 输入数组
2. q 要计算的百分位数，在 0 ~ 100 之间
3. axis 沿着它计算百分位数的轴

笔记：percentile()函数就是根据q（百分比）获得数组中对应的元素，即：该元素在数组的排序中，正处于该百分比位置。

示例

import numpy as np 
a = np.array([[30,40,70],[80,20,10],[50,90,60]])  
print  '我们的数组是：'  
print a 
print  '\n'  
print  '调用 percentile() 函数：'  
print np.percentile(a,50)  
print  '\n'  
print  '沿轴 1 调用 percentile() 函数：'  
print np.percentile(a,50, axis =  1)  
print  '\n'  
print  '沿轴 0 调用 percentile() 函数：'  
print np.percentile(a,50, axis =  0)

#输出如下：
我们的数组是：
[[30 40 70]
 [80 20 10]
 [50 90 60]]
 
调用 percentile() 函数：
50.0
 
沿轴 1 调用 percentile() 函数：
[ 40. 20. 60.]
 
沿轴 0 调用 percentile() 函数：
[ 50. 40. 60.]

numpy.median()

中值定义为将数据样本的上半部分与下半部分 分开的值。 numpy.median()函数的用法如下面的程序所示。

np.median(a, axis =  0)  

示例 获得中值（中间值）

import numpy as np 
a = np.array([[30,65,70],[80,95,10],[50,90,60]])  
print  '我们的数组是：'  
print a 
print  '\n'  
print  '调用 median() 函数：'  
print np.median(a)  
print  '\n'  
print  '沿轴 0 调用 median() 函数：'  
print np.median(a, axis =  0)  
print  '\n'  
print  '沿轴 1 调用 median() 函数：'  
print np.median(a, axis =  1)

# 输出如下： 
我们的数组是：
[[30 65 70]
 [80 95 10]
 [50 90 60]]
 
调用 median() 函数：
65.0
 
沿轴 0 调用 median() 函数：
[ 50. 90. 60.]
 
沿轴 1 调用 median() 函数：
[ 65. 80. 60.]

numpy.mean() 算术平均值

算术平均值是沿轴的元素的总和除以元素的数量。
numpy.mean()函数返回数组中元素的算术平均值。 如果提供了轴，则沿其计算。

示例

import numpy as np 
a = np.array([[1,2,3],[3,4,5],[4,5,6]])  
print  '我们的数组是：'  
print a 
print  '\n'  
print  '调用 mean() 函数：'  
print np.mean(a)  
print  '\n'  
print  '沿轴 0 调用 mean() 函数：'  
print np.mean(a, axis =  0)  
print  '\n'  
print  '沿轴 1 调用 mean() 函数：'  
print np.mean(a, axis =  1)
#输出如下：
我们的数组是：
[[1 2 3]
 [3 4 5]
 [4 5 6]]
 
调用 mean() 函数：
3.66666666667
 
沿轴 0 调用 mean() 函数：
[ 2.66666667 3.66666667 4.66666667]
 
沿轴 1 调用 mean() 函数：
[ 2. 4. 5.]

numpy.average() 加权平均值(应用：卷积)

加权平均值是由每个分量乘以反映其重要性的因子得到的平均值。

numpy.average()函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。 该函数可以接受一个轴参数。 如果没有指定轴，则数组会被展开。

考虑数组[1,2,3,4]和相应的权重[4,3,2,1]，通过将相应元素的乘积相加，并将和除以权重的和，来计算加权平均值。

加权平均值 = (14+23+32+41)/(4+3+2+1)

注意：不指定权重时相当于 mean 平均值函数

示例

import numpy as np 
a = np.array([1,2,3,4])  
print  '我们的数组是：'  
print a 
print  '\n'  
print  '调用 average() 函数：'  
print np.average(a)  
print  '\n'  
# 不指定权重时相当于 mean 函数
wts = np.array([4,3,2,1])  
print  '再次调用 average() 函数：'  
print np.average(a,weights = wts)  
print  '\n'  
# 如果 returned 参数设为 true，则返回权重的和  
print  '权重的和：'  
print np.average([1,2,3,4], weights = [4,3,2,1], returned =  True)

# 输出如下：
我们的数组是：
[1 2 3 4]
 
调用 average() 函数：
2.5
 
再次调用 average() 函数：
2.0
 
权重的和：
(2.0, 10.0)

在多维数组中，可以指定用于计算的轴。

示例

import numpy as np 
a = np.arange(6).reshape(3,2)  
print  '我们的数组是：'  
print a 
print  '\n'  
print  '修改后的数组：' 
wt = np.array([3,5])  
print np.average(a, axis =  1, weights = wt)  
print  '\n'  
print  '修改后的数组：'  
print np.average(a, axis =  1, weights = wt, returned =  True)
# 输出如下：
我们的数组是：
[[0 1]
 [2 3]
 [4 5]]
 
修改后的数组：
[ 0.625 2.625 4.625]
 
修改后的数组：
(array([ 0.625, 2.625, 4.625]), array([ 8., 8., 8.]))

笔记：再论对轴的理解

a=[ [0,1], [2,3], [4,5] ]
wt = np.array([3,5])  
np.average(a, axis =  1, weights = wt)
加权数组[3,5]，average函数axis=1，即：按轴1进行计算
第一维（轴0）的长度是3，第二维（轴1）的长度是2；
(3*0 + 5*1) / 3+5 = 0.625
另两个依次类推

奇怪的是 根据上一函数中对轴的理解，放在这个函数中可能有误。因此，对轴还是没有完全理解！！

标准差 std()

标准差是与均值的偏差的平方的平均值的平方根。
笔记：
即：离均差平方的算术平均数（即：方差）的算术平方根。
标准差能反映一个数据集的离散程度。平均数相同的两组数据，标准差未必相同。

标准差公式如下： std()

std = sqrt( mean( (x - x.mean())**2 ) )
注：sqrt()计算平方根的函数

如果数组是[1，2，3，4]，则其平均值为2.5。 因此，差的平方是[2.25,0.25,0.25,2.25]，并且其平均值的平方根除以4，即sqrt(5/4)是1.1180339887498949。

示例

import numpy as np 
print np.std([1,2,3,4])
# 输出如下：
1.1180339887498949 

方差 var()

方差是偏差的平方的平均值，即mean((x - x.mean())** 2)。 换句话说，标准差是方差的平方根。
笔记：

• 方差是在概率论和统计方差衡量随机变量或一组数据时离散程度的度量。
  概率论中方差用来度量随机变量和其数学期望（即均值）之间的 偏离程度 。
• 统计中的方差（样本方差）是每个样本值与全体样本值的平均数之差的平方值的平均数。在许多实际问题中，研究方差即偏离程度有着重要意义。
• 方差是衡量源数据和期望值相差的度量值。

示例

import numpy as np 
print np.var([1,2,3,4])
# 输出如下：
1.25

笔记：标准差与方差的数学解释

NumPy - 排序、搜索和计数函数

NumPy中提供了各种排序相关功能。 这些排序函数实现不同的排序算法，每个排序算法的特征在于执行速度，最坏情况性能，所需的工作空间和算法的稳定性。 下表显示了三种排序算法的比较。

种类	速度	最坏情况	工作空间	稳定性
‘quicksort’（快速排序）	1	O(n^2)	0	否
‘mergesort’（归并排序）	2	O(n*log(n))	~n/2	是
‘heapsort’（堆排序）	3	O(n*log(n))	0	否

numpy.sort() 直接排序，返回副本

sort()函数返回输入数组的排序副本。 它有以下参数：

numpy.sort(a, axis, kind, order)

参数及描述

1. a 要排序的数组
2. axis 沿着它排序数组的轴，如果没有数组会被展开，沿着最后的轴排序
3. kind 默认为’quicksort’（快速排序）
4. order 如果数组包含字段，则是要排序的字段

示例 排序

import numpy as np  

a = np.array([[3,7],[9,1]])  
print  '我们的数组是：'  
print a 
print  '\n'  
print  '调用 sort() 函数：'  
print np.sort(a)  
print  '\n'  
print  '沿轴 0 排序：'  
print np.sort(a, axis =  0)  
print  '\n'  
# 在 sort 函数中排序字段 
dt = np.dtype([('name',  'S10'),('age',  int)])   # 创造新的数据结构dt
a = np.array([("raju",21),("anil",25),("ravi",  17),  ("amar",27)], dtype = dt)  
print  '我们的数组是：'  
print a 
print  '\n'  
print  '按 name 排序：'  
print np.sort(a, order =  'name')   

# 输出如下：

我们的数组是：
[[3 7]
 [9 1]]
 
调用 sort() 函数：
[[3 7]
 [1 9]]
 
沿轴 0 排序：
[[3 1]
 [9 7]]
 
我们的数组是：
[('raju', 21) ('anil', 25) ('ravi', 17) ('amar', 27)]
 
按 name 排序：
[('amar', 27) ('anil', 25) ('raju', 21) ('ravi', 17)]

numpy.argsort() 间接排序，返回索引数组

numpy.argsort()函数对输入数组沿给定轴执行间接排序，并使用指定排序类型返回数据的索引数组。 这个索引数组用于构造排序后的数组。

示例

import numpy as np 
x = np.array([3,  1,  2])  
print  '我们的数组是：'  
print x 
print  '\n'  
print  '对 x 调用 argsort() 函数：' 
y = np.argsort(x)  
print y 
print  '\n'  
print  '以排序后的顺序重构原数组：'  
print x[y]  
print  '\n'  
print  '使用循环重构原数组：'  
for i in y:  
    print x[i],

# 输出如下：

 
我们的数组是：
[3 1 2]
 
对 x 调用 argsort() 函数：
[1 2 0]
 
以排序后的顺序重构原数组：
[1 2 3]
 
使用循环重构原数组：
1 2 3

numpy.lexsort() 键序列 间接排序

函数使用键序列执行间接排序。 键可以看作是电子表格中的一列。
该函数返回一个索引数组，使用它可以获得排序数据。
注意，最后一个键恰好是 sort 的主键。

示例

import numpy as np
a=[0,4,0,3,2,3,3]
b=[10,5,1,5,1,3,1]
c=np.lexsort((b,a))
print("c:",c)
print([b[i] for i in c])
print([str(b[i]) +","+str(a[i]) for i in c])

# 输出结果
c: [2 0 4 6 5 3 1]
[1, 10, 1, 1, 3, 5, 5]
['1,0', '10,0', '1,2', '1,3', '3,3', '5,3', '5,4']

#一种错误的写法
c=np.lexsort(a)
print("c:",c)
#输出结果
c: 0

笔记：对于lexsort()排序的理解

• lexsort（）对参数2（数组）进行排序，并返回排序后的索引数组
• 通过索引数组最参数1（数组）进行间距排序（与参数2顺序索引一致）
• 参数2（数组）进行排序逻辑，先根据参数2数组的最后一个元素进行排序，如果最后一个元素有相同的值，则根据倒数第二个元素进行排序，以此类推。即：遇到相同元素，排序优先级在右侧。

NumPy 数组内搜索函数

NumPy 模块有一些用于在数组内搜索的函数。 提供了用于找到最大值，最小值以及满足给定条件的元素的函数。

numpy.argmax() 和 numpy.argmin() 最大值与最小值

这两个函数分别沿给定轴返回最大和最小元素的索引。
注意：返回值为数组索引

示例

import numpy as np 
a = np.array([[30,40,70],[80,20,10],[50,90,60]])  
print  '我们的数组是：'  
print a 
print  '\n'  
print  '调用 argmax() 函数：'  
print np.argmax(a)     # 没有轴向时，会将数组展开后获取最大值
print  '\n'  
print  '展开数组：'  
print a.flatten()     # 返回一维数组
print  '\n'  
print  '沿轴 0 的最大值索引：' 
maxindex = np.argmax(a, axis =  0)  
print maxindex 
print  '\n'  
print  '沿轴 1 的最大值索引：' 
maxindex = np.argmax(a, axis =  1)  
print maxindex 
print  '\n'  
print  '调用 argmin() 函数：' 
minindex = np.argmin(a)  
print minindex 
print  '\n'  
print  '展开数组中的最小值：'  
print a.flatten()[minindex]    # 返回一维数组，之后通过索引获得该值： 数组[minindex]
print  '\n'  
print  '沿轴 0 的最小值索引：' 
minindex = np.argmin(a, axis =  0)  
print minindex 
print  '\n'  
print  '沿轴 1 的最小值索引：' 
minindex = np.argmin(a, axis =  1)  
print minindex

输出如下：

 
我们的数组是：
[[30 40 70]
 [80 20 10]
 [50 90 60]]
 
调用 argmax() 函数：
7
 
展开数组：
[30 40 70 80 20 10 50 90 60]
 
沿轴 0 的最大值索引：
[1 2 0]
 
沿轴 1 的最大值索引：
[2 0 1]
 
调用 argmin() 函数：
5
 
展开数组中的最小值：
10
 
沿轴 0 的最小值索引：
[0 1 1]
 
沿轴 1 的最小值索引：
[0 2 0]

numpy.nonzero()

numpy.nonzero()函数返回输入数组中非零元素的索引。

示例

import numpy as np 
a = np.array([[30,40,0],[0,20,10],[50,0,60]])  
print  '我们的数组是：'  
print a 
print  '\n'  
print  '调用 nonzero() 函数：'  
print np.nonzero (a)
输出如下：

 
我们的数组是：
[[30 40 0]
 [ 0 20 10]
 [50 0 60]]
 
调用 nonzero() 函数：
(array([0, 0, 1, 1, 2, 2], dtype=int64), array([0, 1, 1, 2, 0, 2], dtype=int64))

笔记：nonzero(a）的结果，第一个数组是行坐标，第二数组是列坐标，也就是说上下对应着看，就是原二维数组中位置坐标，

numpy.where()

where()函数返回输入数组中满足给定条件的元素的索引。

示例

import numpy as np 
x = np.arange(9.).reshape(3,  3)  
print  '我们的数组是：'  
print x 
print  '大于 3 的元素的索引：' 
y = np.where(x >  3)  
print y 
print  '使用这些索引来获取满足条件的元素：'  
print x[y]
输出如下：

我们的数组是：
[[ 0. 1. 2.]
 [ 3. 4. 5.]
 [ 6. 7. 8.]]
 
大于 3 的元素的索引：
(array([1, 1, 2, 2, 2]), array([1, 2, 0, 1, 2]))
 
使用这些索引来获取满足条件的元素：
[ 4. 5. 6. 7. 8.]

numpy.extract()

extract()函数返回满足任何条件的元素。

import numpy as np 
x = np.arange(9.).reshape(3,  3)  
print  '我们的数组是：'  
print x 
# 定义条件 
condition = np.mod(x,2)  ==  0  
print  '按元素的条件值：'  
print condition 
print  '使用条件提取元素：'  
print np.extract(condition, x)
输出如下：

 
我们的数组是：
[[ 0. 1. 2.]
 [ 3. 4. 5.]
 [ 6. 7. 8.]]
 
按元素的条件值：
[[ True False True]
 [False True False]
 [ True False True]]
 
使用条件提取元素：
[ 0. 2. 4. 6. 8.]

NumPy - 字节交换

我们已经看到，存储在计算机内存中的数据取决于 CPU 使用的架构。 它可以是小端（最小有效位存储在最小地址中）或大端（最小有效字节存储在最大地址中）。

numpy.ndarray.byteswap()

numpy.ndarray.byteswap()函数在两个表示：大端和小端之间切换。

import numpy as np 
a = np.array([1,  256,  8755], dtype = np.int16)  
print  '我们的数组是：'  
print a 
print  '以十六进制表示内存中的数据：'  
print map(hex,a)  
# byteswap() 函数通过传入 true 来原地交换 
print  '调用 byteswap() 函数：'  
print a.byteswap(True)  
print  '十六进制形式：'  
print map(hex,a)  
# 我们可以看到字节已经交换了
输出如下：

我们的数组是：
[1 256 8755]
 
以十六进制表示内存中的数据：
['0x1', '0x100', '0x2233']
 
调用 byteswap() 函数：
[256 1 13090]
 
十六进制形式：
['0x100', '0x1', '0x3322']

NumPy - 副本和视图

在执行函数时，其中一些返回输入数组的副本，而另一些返回视图。 当内容物理存储在另一个位置时，称为副本。 另一方面，如果提供了相同内存内容的不同视图，我们将其称为视图。

无复制

简单的赋值不会创建数组对象的副本。 相反，它使用原始数组的相同id()来访问它。 **id()**返回 Python 对象的通用标识符，类似于 C 中的指针。

此外，一个数组的任何变化都反映在另一个数组上。 例如，一个数组的形状改变也会改变另一个数组的形状。

示例

import numpy as np 
a = np.arange(6)  
print  '我们的数组是：'  
print a 
print  '调用 id() 函数：'  
print id(a)  
print  'a 赋值给 b：' 
b = a 
print b 
print  'b 拥有相同 id()：'  
print id(b)  
print  '修改 b 的形状：' 
b.shape =  3,2  
print b 
print  'a 的形状也修改了：'  
print a

输出如下：

 
我们的数组是：
[0 1 2 3 4 5]
 
调用 id() 函数：
139747815479536
 
a 赋值给 b：
[0 1 2 3 4 5]
b 拥有相同 id()：
139747815479536
 
修改 b 的形状：
[[0 1]
 [2 3]
 [4 5]]
 
a 的形状也修改了：
[[0 1]
 [2 3]
 [4 5]]

视图或浅复制 ndarray.view()

NumPy 拥有 ndarray.view ()方法，它是一个新的数组对象，并可查看原始数组的相同数据。
与前一种情况不同，新数组的维数更改不会更改原始数据的维数。

示例

import numpy as np 
# 最开始 a 是个 3X2 的数组
a = np.arange(6).reshape(3,2)  
print  '数组 a：'  
print a 
print  '创建 a 的视图：' 
b = a.view()  
print b 
print  '两个数组的 id() 不同：'  
print  'a 的 id()：'  
print id(a)  
print  'b 的 id()：'  
print id(b)  
# 修改 b 的形状，并不会修改 a
b.shape =  2,3  
print  'b 的形状：'  
print b 
print  'a 的形状：'  
print a

输出如下：

 
数组 a：
[[0 1]
 [2 3]
 [4 5]]
 
创建 a 的视图：
[[0 1]
 [2 3]
 [4 5]]
 
两个数组的 id() 不同：
a 的 id()：
140424307227264
b 的 id()：
140424151696288
 
b 的形状：
[[0 1 2]
 [3 4 5]]
 
a 的形状：
[[0 1]
 [2 3]
 [4 5]]

数组的切片也会创建视图：

示例

import numpy as np 
a = np.array([[10,10],  [2,3],  [4,5]])  
print  '我们的数组：'  
print a 
print  '创建切片：' 
s = a[:,  :2]  
print s 
输出如下：

 
我们的数组：
[[10 10]
 [ 2 3]
 [ 4 5]]
 
创建切片：
[[10 10]
 [ 2 3]
 [ 4 5]]

深复制 ndarray.copy()

ndarray.copy()函数创建一个深层副本。 它是数组及其数据的完整副本，不与原始数组共享。

示例

import numpy as np 
a = np.array([[10,10],  [2,3],  [4,5]])  
print  '数组 a：'  
print a 
print  '创建 a 的深层副本：' 
b = a.copy()  
print  '数组 b：'  
print b 
# b 与 a 不共享任何内容  
print  '我们能够写入 b 来写入 a 吗？'  
print b is a 
print  '修改 b 的内容：' 
b[0,0]  =  100  
print  '修改后的数组 b：'  
print b 
print  'a 保持不变：'  
print a

输出如下：

 
数组 a：
[[10 10]
 [ 2 3]
 [ 4 5]]
 
创建 a 的深层副本：
数组 b：
[[10 10]
 [ 2 3]
 [ 4 5]]
我们能够写入 b 来写入 a 吗？
False
 
修改 b 的内容：
修改后的数组 b：
[[100 10]
 [ 2 3]
 [ 4 5]]
 
a 保持不变：
[[10 10]
 [ 2 3]
 [ 4 5]]

NumPy - 矩阵库

NumPy 包包含一个 Matrix库numpy.matlib。此模块的函数返回矩阵而不是返回ndarray对象。

matlib.empty()

matlib.empty()函数返回一个新的矩阵，而不初始化元素。 该函数接受以下参数。

numpy.matlib.empty(shape, dtype, order)

其中：

1. shape 定义新矩阵形状的整数或整数元组
2. Dtype 可选，输出的数据类型
3. order C 或者 F

示例

import numpy.matlib 
import numpy as np 
print np.matlib.empty((2,2))  
# 填充为随机数据
输出如下：

[[ 2.12199579e-314,   4.24399158e-314] 
 [ 4.24399158e-314,   2.12199579e-314]] 

numpy.matlib.zeros()

此函数返回以零填充的矩阵。

import numpy.matlib 
import numpy as np 
print np.matlib.zeros((2,2))  
输出如下： 
[[ 0.  0.] 
 [ 0.  0.]]) 

numpy.matlib.ones()

此函数返回以一填充的矩阵。

import numpy.matlib 
import numpy as np 
print np.matlib.ones((2,2))
输出如下：

[[ 1.  1.] 
 [ 1.  1.]] 

numpy.matlib.eye()

这个函数返回一个矩阵，对角线元素为 1，其他位置为零。 该函数接受以下参数。

numpy.matlib.eye(n, M,k, dtype)

其中：

1. n 返回矩阵的行数
2. M 返回矩阵的列数，默认为n
3. k 对角线的索引
4. dtype 输出的数据类型

示例

import numpy.matlib 
import numpy as np 
print np.matlib.eye(n =  3, M =  4, k =  0, dtype =  float)
输出如下：
[[ 1.  0.  0.  0.] 
 [ 0.  1.  0.  0.] 
 [ 0.  0.  1.  0.]]) 

numpy.matlib.identity()

numpy.matlib.identity()函数返回给定大小的单位矩阵。单位矩阵是主对角线元素都为 1 的方阵。

import numpy.matlib 
import numpy as np 
print np.matlib.identity(5, dtype =  float)
输出如下：

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

numpy.matlib.rand()

numpy.matlib.rand() 函数返回给定大小的填充随机值的矩阵。

示例

import numpy.matlib 
import numpy as np 
print np.matlib.rand(3,3)
输出如下：

[[ 0.82674464  0.57206837  0.15497519] 
 [ 0.33857374  0.35742401  0.90895076] 
 [ 0.03968467  0.13962089  0.39665201]]

矩阵与ndarray互换

注意，矩阵总是二维的，而ndarray是一个 n 维数组。 两个对象都是可互换的。

示例 matrix

import numpy.matlib 
import numpy as np  
 
i = np.matrix('1,2;3,4')  
print i      # matrix  矩阵类型
输出如下：

[[1  2] 
 [3  4]]

示例 asarray（）函数 将matrix转换为ndarray

j = np.asarray(i)  
print j 
输出如下：

[[1  2] 
 [3  4]] 

示例 asmatrix () 函数 将ndarray 转换为 matrix

k = np.asmatrix (j)  
print k
输出如下：

[[1  2] 
 [3  4]]

NumPy - 线性代数

NumPy 包包含numpy.linalg模块，提供线性代数所需的所有功能。 此模块中的一些重要功能如下表所述。

1. dot 两个数组的点积
2. vdot 两个向量的点积
3. inner 两个数组的内积
4. matmul 两个数组的矩阵积
5. determinant 数组的行列式
6. solve 求解线性矩阵方程
7. inv 寻找矩阵的乘法逆矩阵

笔记：名词解释

• 欧几里得空间
  欧几里得空间（Euclidean space），是指一类特殊的向量空间，对通常3维空间V3中的向量可以讨论长度、夹角等几何性质。
• 点积
  点积在数学中，又称数量积（dot product; scalar product），是指接受在实数R上的两个向量并返回一个实数值标量的二元运算。
  它是欧几里得空间的标准内积。
  两个向量a = [a1, a2,…, an]和b = [b1, b2,…, bn]的点积定义为：
  a·b=a1b1+a2b2+……+anbn。
  使用矩阵乘法并把（纵列）向量当作n×1 矩阵，点积还可以写为：
  a·b=（a^T）*b ，
  这里的 a^T指示矩阵a的转置。
• 内积
  内积一般指点积。 点积在数学中，又称数量积。
  那么，内积、点积、数量积有和区别呢？
  一、用法不同：
  内积是相对于内积空间来说的，它的含义要远远高于一般的「点积」或者「数量积」，后者只是前者的某种特例而已。
  一个内积空间不只是「可以是无限维的欧几里德空间」那么简单，它的内积可以自然引导出「范数」，也就是说它天然是一个距离空间。它和同样具备「范数」的一般赋范空间线性空间也是有所区别的。
  二、算法不同：
  数量积的结果是数值,向量积的结果仍然是向量，向量积（带方向）:也被称为矢量积、叉积（即交叉乘积）、外积是一种在向量空间中向量的二元运算。与点积不同，它的运算结果是一个伪向量而不是一个标量。并且两个向量的叉积与这两个向量都垂直。

numpy.dot() 数组的点积

此函数返回两个数组的点积。

• 对于二维向量，其等效于矩阵乘法。
• 对于一维数组，它是向量的内积。
• 对于 N 维数组，它是a的最后一个轴上的和与b的倒数第二个轴的乘积。

import numpy.matlib 
import numpy as np 
 
a = np.array([[1,2],[3,4]]) 
b = np.array([[11,12],[13,14]]) 
np.dot(a,b)   #此时，点积做矩阵乘法 即：a*b
# 输出如下：

[[37  40] 
 [85  92]] 

矩阵乘法公式：
a x b =
[ [a行1 x b列1， a行1 x b列2]
[a行2 x b列1， a行2 x b列2 ] ]

要注意点积计算为：
[ [1x11+2x13, 1x12+2x14],
[3x11+4x13, 3x12+4x14] ]

numpy.vdot() 两向量的点积

此函数返回两个向量的点积。

• 如果第一个参数是复数，那么它的共轭复数会用于计算。
• 如果参数id是多维数组，它会被展开。

笔记：注意向量的点积与数组点积完全不同，最后获得一个向量值。但是没有方向？
算法为 111 + 212 + 313 + 414 = 130。

例子

import numpy as np 

a = np.array([[1,2],[3,4]]) 
b = np.array([[11,12],[13,14]]) 
print np.vdot(a,b)

输出如下：
130
注意：1*11 + 2*12 + 3*13 + 4*14 = 130。

numpy.inner() 一维数组的向量内积

此函数返回一维数组的向量内积。

• 对于更高的维度，它返回最后一个轴上的和的乘积。

例子

import numpy as np 
print np.inner(np.array([1,2,3]),np.array([0,1,0])) 
# 等价于 1*0+2*1+3*0
输出如下：
2

numpy.inner() 多维数组向量内积

对于更高的维度，它返回最后一个轴上的和的乘积。
例子

import numpy as np 

a = np.array([[1,2], [3,4]]) 
print '数组 a：' 
print a 
b = np.array([[11, 12], [13, 14]]) 
print '数组 b：' 
print b 
 
print '内积：' 
print np.inner(a,b)

输出如下：
数组 a：
[[1 2]
[3 4]]
 
数组 b：
[[11 12]
[13 14]]
 
内积：
[[35 41]
[81 95]]

上面的例子中，内积计算如下：
1x11+2x12, 1x13+2x14
3x11+4x12, 3x13+4x14

笔记：inner向量的内积用的不是矩阵乘法，需要再学习一下！！

numpy.matmul（） 两个数组的矩阵乘积

numpy.matmul()函数返回两个数组的矩阵乘积。 虽然它返回二维数组的正常乘积，

• 但如果任一参数的维数大于2，则将其视为存在于最后两个索引的矩阵的栈，并进行相应广播。
• 另一方面，如果任一参数是一维数组，则通过在其维度上附加 1 来将其提升为矩阵，并在乘法之后被去除。

例子 二维数组乘法，即矩阵乘法

# 对于二维数组，它就是矩阵乘法
import numpy.matlib 
import numpy as np 
 
a = [[1,0],[0,1]] 
b = [[4,1],[2,2]] 
print np.matmul(a,b)

输出如下：
[[4  1] 
 [2  2]] 

例子 二维与一维数组的乘法运算

 
# 二维和一维运算
import numpy.matlib    # 矩阵类
import numpy as np 
 
a = [[1,0],[0,1]]      
b = [1,2] 

print np.matmul(a,b) 
print np.matmul(b,a)

输出如下：
[1  2] 
[1  2] 

例子 二维以上数组的乘法

# 维度大于二的数组 
import numpy.matlib 
import numpy as np 
 
a = np.arange(8).reshape(2,2,2) 
b = np.arange(4).reshape(2,2) 
print np.matmul(a,b)

输出如下：
[[[2   3] 
   [6   11]] 
  [[10  19] 
   [14  27]]]

笔记：二维以上乘法需要学习算法！！！

numpy.linalg.det() 计算输入矩阵的行列式

行列式在线性代数中是非常有用的值。
它从方阵的对角元素计算。 对于 2×2 矩阵，它是左上和右下元素的乘积与其他两个的乘积的差。

换句话说，对于矩阵[[a，b]，[c，d]]，行列式计算为ad-bc。 较大的方阵被认为是 2×2 矩阵的组合。

笔记：
行列式在数学中，是一个函数，其定义域为det的矩阵A，取值为一个标量，写作det(A)或 | A | 。无论是在线性代数、多项式理论，还是在微积分学中（比如说换元积分法中），行列式作为基本的数学工具，都有着重要的应用。
行列式可以看做是有向面积或体积的概念在一般的欧几里得空间中的推广。或者说，在 n 维欧几里得空间中，行列式描述的是一个线性变换对“体积”所造成的影响。

numpy.linalg.det()函数计算输入矩阵的行列式。

例子 2*2矩阵行列式

 
import numpy as np
a = np.array([[1,2], [3,4]]) 
print np.linalg.det(a)

输出如下：
-2.0

例子 多维矩阵行列式

b = np.array([[6,1,1], [4, -2, 5], [2,8,7]]) 
print b 
print np.linalg.det(b) 
print 6*(-2*7 - 5*8) - 1*(4*7 - 5*2) + 1*(4*8 - -2*2)

输出如下：
[[ 6 1 1]
 [ 4 -2 5]
 [ 2 8 7]]
 
-306.0
 
-306

numpy.linalg.solve() 矩阵形式的线性方程的解

numpy.linalg.solve()函数给出了矩阵形式的线性方程的解。

考虑以下线性方程：

x + y + z = 6
2y + 5z = -4
2x + 5y - z = 27

可以使用矩阵表示为：

如果矩阵成为A、X和B，方程变为：

AX = B
或
X = A^(-1)B

numpy.linalg.inv() 计算矩阵的逆

我们使用numpy.linalg.inv()函数来计算矩阵的逆。 矩阵的逆是这样的，如果它乘以原始矩阵，则得到单位矩阵。

笔记：单位矩阵
在矩阵的乘法中，有一种矩阵起着特殊的作用，如同数的乘法中的1，这种矩阵被称为单位矩阵。它是个方阵，从左上角到右下角的对角线（称为主对角线）上的元素均为1。除此以外全都为0。

例子 求矩阵X的逆

import numpy as np 
 
x = np.array([[1,2],[3,4]]) 
y = np.linalg.inv(x) 
print x 
print y 
print np.dot(x,y)

输出如下：
[[1 2]                                                                        
 [3 4]]                                                                       
[[-2.   1. ]                                                                  
 [ 1.5 -0.5]]                                                                 
[[  1.00000000e+00   1.11022302e-16]                                          
 [  0.00000000e+00   1.00000000e+00]]

例子 : 现在让我们在示例中创建一个矩阵A的逆。

 
import numpy as np 
a = np.array([[1,1,1],[0,2,5],[2,5,-1]]) 
 
print '数组 a：'
print a 
ainv = np.linalg.inv(a) 
 
print 'a 的逆：' 
print ainv  
 
print '矩阵 b：' 
b = np.array([[6],[-4],[27]]) 
print b 
 
print '计算：A^(-1)B：' 
x = np.linalg.solve(a,b) 
print x  
# 这就是线性方向 x = 5, y = 3, z = -2 的解

输出如下：
数组 a：
[[ 1 1 1]
 [ 0 2 5]
 [ 2 5 -1]]
 
a 的逆：
[[ 1.28571429 -0.28571429 -0.14285714]
 [-0.47619048 0.14285714 0.23809524]
 [ 0.19047619 0.14285714 -0.0952381 ]]
 
矩阵 b：
[[ 6]
 [-4]
 [27]]
 
计算：A^(-1)B：
[[ 5.]
 [ 3.]
 [-2.]]

结果也可以使用下列函数获取

x = np.dot(ainv,b)

NumPy - Matplotlib 绘图库

Matplotlib 是 Python 的绘图库。 它可与 NumPy 一起使用，提供了一种有效的 MatLab 开源替代方案。 它也可以和图形工具包一起使用，如 PyQt 和 wxPython。

Matplotlib 模块最初是由 John D. Hunter 编写的。 自 2012 年以来，Michael Droettboom 是主要开发者。 目前，Matplotlib 1.5.1 是可用的稳定版本。 该软件包可以二进制分发，其源代码形式在 www.matplotlib.org 上提供。

通常，通过添加以下语句将包导入到 Python 脚本中：

	from matplotlib import pyplot as plt

这里pyplot()是 matplotlib 库中最重要的函数，用于绘制 2D 数据。 以下脚本绘制方程 y = 2x + 5：

示例

import numpy as np 
from matplotlib import pyplot as plt 
 
x = np.arange(1,11) 
y =  2  * x +  5 
plt.title("Matplotlib demo") 
plt.xlabel("x axis caption") 
plt.ylabel("y axis caption") 
plt.plot(x,y) 
plt.show()

ndarray对象x由np.arange()函数创建为x轴上的值。y轴上的对应值存储在另一个数组对象y中。 这些值使用matplotlib软件包的pyplot子模块的plot()函数绘制。

图形由show()函数展示。

上面的代码应该产生以下输出：

Matplotlib Demo

作为线性图的替代，可以通过向plot()函数添加格式字符串来显示离散值。 可以使用以下格式化字符。

字符	描述
‘-’	实线样式
‘–’	短横线样式
‘-.’	点划线样式
‘:’	虚线样式
‘.’	点标记
‘,’	像素标记
‘o’	圆标记
‘v’	倒三角标记
‘^’	正三角标记
‘<’	左三角标记
‘>’	右三角标记
‘1’	下箭头标记
‘2’	上箭头标记
‘3’	左箭头标记
‘4’	右箭头标记
‘s’	正方形标记
‘p’	五边形标记
‘*’	星形标记
‘h’	六边形标记 1
‘H’	六边形标记 2
‘+’	加号标记
‘x’	X 标记
‘D’	菱形标记
‘d’	窄菱形标记
' '	竖直线标记
‘_’	水平线标记

还定义了以下颜色缩写。

Color Abbreviation 颜色缩略符

字符	颜色
‘b’	蓝色
‘g’	绿色
‘r’	红色
‘c’	青色
‘m’	品红色
‘y’	黄色
‘k’	黑色
‘w’	白色

要显示圆来代表点，而不是上面示例中的线，请使用ob作为plot()函数中的格式字符串。

示例 圆来代表点

import numpy as np 
from matplotlib import pyplot as plt 
 
x = np.arange(1,11) 
y =  2  * x +  5 
plt.title("Matplotlib demo") 
plt.xlabel("x axis caption") 
plt.ylabel("y axis caption") 
plt.plot(x,y,"ob") 
plt.show()  

上面的代码应该产生以下输出：

绘制正弦波 Sine Wave

以下脚本使用 matplotlib 生成正弦波图。

示例

import numpy as np 
import matplotlib.pyplot as plt 
# 计算正弦曲线上点的 x 和 y 坐标
x = np.arange(0,  3  * np.pi,  0.1) 
y = np.sin(x)
plt.title("sine wave form")  
# 使用 matplotlib 来绘制点
plt.plot(x, y) 
plt.show()  

subplot() - Sub Plot

subplot()函数允许你在同一图中绘制不同的东西。 在下面的脚本中，绘制正弦和余弦值。

示例

import numpy as np 
import matplotlib.pyplot as plt 
# 计算正弦和余弦曲线上的点的 x 和 y 坐标 
x = np.arange(0,  3  * np.pi,  0.1) 
y_sin = np.sin(x) 
y_cos = np.cos(x)  
# 建立 subplot 网格，高为 2，宽为 1  
# 激活第一个 subplot
plt.subplot(2,  1,  1)  
# 绘制第一个图像 
plt.plot(x, y_sin) 
plt.title('Sine')  
# 将第二个 subplot 激活，并绘制第二个图像
plt.subplot(2,  1,  2) 
plt.plot(x, y_cos) 
plt.title('Cosine')  
# 展示图像
plt.show()

上面的代码应该产生以下输出：

bar() 条形图

pyplot子模块提供bar()函数来生成条形图。 以下示例生成两组x和y数组的条形图。

示例

from matplotlib import pyplot as plt 
x =  [5,8,10] 
y =  [12,16,6] 
x2 =  [6,9,11] 
y2 =  [6,15,7] 
plt.bar(x, y, align =  'center') 
plt.bar(x2, y2, color =  'g', align =  'center') 
plt.title('Bar graph') 
plt.ylabel('Y axis') 
plt.xlabel('X axis') 
plt.show()

NumPy - 使用 Matplotlib 绘制直方图

NumPy 有一个numpy.histogram()函数，它是数据的频率分布的图形表示。 水平尺寸相等的矩形对应于类间隔，称为bin，变量height对应于频率。

numpy.histogram()

numpy.histogram()函数将输入数组和bin作为两个参数。 bin数组中的连续元素用作每个bin的边界。

import numpy as np 
 
a = np.array([22,87,5,43,56,73,55,54,11,20,51,5,79,31,27]) ]
np.histogram(a,bins =  [0,20,40,60,80,100]) 
hist,bins = np.histogram(a,bins =  [0,20,40,60,80,100])  
print hist 
print bins 
输出如下：

[3 4 5 2 1]
[0 20 40 60 80 100]

plt() Histogram Plot

Matplotlib 可以将直方图的数字表示转换为图形。 pyplot子模块的plt()函数将包含数据和bin数组的数组作为参数，并转换为直方图。

from matplotlib import pyplot as plt 
import numpy as np  
 
a = np.array([22,87,5,43,56,73,55,54,11,20,51,5,79,31,27]) 
plt.hist(a, bins =  [0,20,40,60,80,100]) 
plt.title("histogram") 
plt.show()

输出如下：

NumPy - IO

ndarray对象可以保存到磁盘文件并从磁盘文件加载。 可用的 IO 功能有：

• load()和save()函数处理 numPy 二进制文件（带npy扩展名）

• loadtxt()和savetxt()函数处理正常的文本文件

NumPy 为ndarray对象引入了一个简单的文件格式。 这个npy文件在磁盘文件中，存储重建ndarray所需的数据、图形、dtype和其他信息，以便正确获取数组，即使该文件在具有不同架构的另一台机器上。

numpy.save() and numpy.load()

numpy.save()文件将输入数组存储在具有npy扩展名的磁盘文件中。

import numpy as np 
a = np.array([1,2,3,4,5]) 
np.save('outfile',a)

为了从outfile.npy重建数组，请使用load()函数。

import numpy as np 
b = np.load('outfile.npy')  
print b 
输出如下：
array([1, 2, 3, 4, 5])

save()和load()函数接受一个附加的布尔参数allow_pickles。 Python 中的pickle用于在保存到磁盘文件或从磁盘文件读取之前，对对象进行序列化和反序列化。

savetxt() and loadtxt()

以简单文本文件格式存储和获取数组数据，是通过savetxt()和loadtx()函数完成的。

示例

import numpy as np 
 
a = np.array([1,2,3,4,5]) 
np.savetxt('out.txt',a) 
b = np.loadtxt('out.txt')  
print b 
输出如下：

[ 1.  2.  3.  4.  5.] 

savetxt()和loadtxt()数接受附加的可选参数，例如页首，页尾和分隔符。

NumPy - 实用资源

以下资源包含有关 NumPy 的其他信息。 请使用它们获得更多的深入知识。

试验性 Numpy 教程
100 numpy exercises
From Python to Numpy
Matplotlib 教程

转载链接：https://www.jianshu.com/p/57e3c0a92f3a