# 矩阵系列

## 1.创建特殊矩阵

### 1.1.创建全为0的矩阵

`np.zeros(tuple)`

`import numpy as np`
`help(np.zeros)`
```Help on built-in function zeros in module numpy.core.multiarray:

zeros(...)
zeros(shape, dtype=float, order='C')

Return a new array of given shape and type, filled with zeros.

Parameters
----------
shape : int or sequence of ints
Shape of the new array, e.g., ``(2, 3)`` or ``2``.
dtype : data-type, optional
The desired data-type for the array, e.g., `numpy.int8`.  Default is
`numpy.float64`.
order : {'C', 'F'}, optional
Whether to store multidimensional data in C- or Fortran-contiguous
(row- or column-wise) order in memory.

Returns
-------
out : ndarray
Array of zeros with the given shape, dtype, and order.

--------
zeros_like : Return an array of zeros with shape and type of input.
ones_like : Return an array of ones with shape and type of input.
empty_like : Return an empty array with shape and type of input.
ones : Return a new array setting values to one.
empty : Return a new uninitialized array.

Examples
--------
>>> np.zeros(5)
array([ 0.,  0.,  0.,  0.,  0.])

>>> np.zeros((5,), dtype=int)
array([0, 0, 0, 0, 0])

>>> np.zeros((2, 1))
array([[ 0.],
[ 0.]])

>>> s = (2,2)
>>> np.zeros(s)
array([[ 0.,  0.],
[ 0.,  0.]])

>>> np.zeros((2,), dtype=[('x', 'i4'), ('y', 'i4')]) # custom dtype
array([(0, 0), (0, 0)],
dtype=[('x', '<i4'), ('y', '<i4')])```
```# 一维
np.zeros(5) # 完整写法：np.zeros((5,))```
`array([0., 0., 0., 0., 0.])`
```# 可以指定类型
np.zeros(5,dtype=int)```
`array([0, 0, 0, 0, 0])`
```# 二维
np.zeros((2,5))```
```array([[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.]])```
```# 三维 ==> 可以这么理解，2个2*5（2行5列）的矩阵
np.zeros((2,2,5))```
```array([[[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.]],

[[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.]]])```
`################### 扩展部分 ########################`
```# 建议用元组，官方文档都是元组，而且shape返回类型就是元组
array1 = np.zeros([2,3])
print(array1)
type(array1)
print(array1.shape) # shape返回类型就是元组```
```[[0. 0. 0.]
[0. 0. 0.]]
(2, 3)```

### 1.2.创建全为1的矩阵

`np.ones(tuple)` 用法和 `np.zeros(tuple)`差不多

`help(np.ones)`
```Help on function ones in module numpy.core.numeric:

ones(shape, dtype=None, order='C')
Return a new array of given shape and type, filled with ones.

Parameters
----------
shape : int or sequence of ints
Shape of the new array, e.g., ``(2, 3)`` or ``2``.
dtype : data-type, optional
The desired data-type for the array, e.g., `numpy.int8`.  Default is
`numpy.float64`.
order : {'C', 'F'}, optional
Whether to store multidimensional data in C- or Fortran-contiguous
(row- or column-wise) order in memory.

Returns
-------
out : ndarray
Array of ones with the given shape, dtype, and order.

--------
zeros, ones_like

Examples
--------
>>> np.ones(5)
array([ 1.,  1.,  1.,  1.,  1.])

>>> np.ones((5,), dtype=int)
array([1, 1, 1, 1, 1])

>>> np.ones((2, 1))
array([[ 1.],
[ 1.]])

>>> s = (2,2)
>>> np.ones(s)
array([[ 1.,  1.],
[ 1.,  1.]])```
```# 一维
np.ones(5) # 完整写法 np.ones((5,))```
`array([1., 1., 1., 1., 1.])`
```# 可以指定类型
np.ones(5,dtype=int)```
`array([1, 1, 1, 1, 1])`
```# 二维，传一个shape元组
np.ones((2,5))```
```array([[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.]])```
```# 三维 可以理解为两个二维数组
np.ones((2,2,5))```
```array([[[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.]],

[[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.]]])```

### 1.3.单位矩阵

`np.eye()` 来定义(eye：眼睛)

`help(np.eye)`
```Help on function eye in module numpy.lib.twodim_base:

eye(N, M=None, k=0, dtype=<class 'float'>, order='C')
Return a 2-D array with ones on the diagonal and zeros elsewhere.

Parameters
----------
N : int
Number of rows in the output.
M : int, optional
Number of columns in the output. If None, defaults to `N`.
k : int, optional
Index of the diagonal: 0 (the default) refers to the main diagonal,
a positive value refers to an upper diagonal, and a negative value
to a lower diagonal.
dtype : data-type, optional
Data-type of the returned array.
order : {'C', 'F'}, optional
Whether the output should be stored in row-major (C-style) or
column-major (Fortran-style) order in memory.

Returns
-------
I : ndarray of shape (N,M)
An array where all elements are equal to zero, except for the `k`-th
diagonal, whose values are equal to one.

--------
identity : (almost) equivalent function
diag : diagonal 2-D array from a 1-D array specified by the user.

Examples
--------
>>> np.eye(2, dtype=int)
array([[1, 0],
[0, 1]])
>>> np.eye(3, k=1)
array([[ 0.,  1.,  0.],
[ 0.,  0.,  1.],
[ 0.,  0.,  0.]])```
```# 定义一个2行的单位矩阵（列默认和行一致）
np.eye(2)```
```array([[1., 0.],
[0., 1.]])```
`np.eye(3,dtype=int)`
```array([[1, 0, 0],
[0, 1, 0],
[0, 0, 1]])```
```# 定义一个5行5列的单位矩阵
np.eye(5)```
```array([[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.]])```

0 条评论

• ### Git异常：fatal: V1.0 cannot be resolved to branch.

GitHub实战系列汇总：http://www.cnblogs.com/dunitian/p/5038719.html ————————————————————...

• ### NET跨平台：在Ubuntu下搭建ASP.NET 5开发环境

0x00 写在前面的废话 年底这段时间实在太忙了，各种事情都凑在这个时候，没时间去学习自己感兴趣的东西，所以博客也好就没写了。最近工作上有个小功能要做成Web应...

• ### Jupyter-Notebook版的博客园美化

文章汇总：https://www.cnblogs.com/dotnetcrazy/p/9160514.html

• ### 【实验楼-Python 科学计算】SciPy - 科学计算库（下）

使用 eigvals 计算矩阵的特征值，使用 eig 同时计算矩阵的特征值与特征向量：

• ### Numpy 简介

标准安装的Python中用列表(list)保存一组值，可以用来当作数组使用，不过由于列表的元素可以是任何对象，因此列表中所保存的是对象的指针。这样为了保存一个简...

• ### 机器学习第3天：多元线性回归

简单线性回归：影响Y的因素唯一，只有一个。 多元线性回归：影响Y的因数不唯一，有多个。

• ### Python中的Numpy入门教程

很简单，Numpy是Python的一个科学计算的库，提供了矩阵运算的功能，其一般与Scipy、matplotlib一起使用。其实，list已经提供了类似于矩阵的...

• ### 设计模式（十二）享元模式

享元模式定义 享元模式是结构型设计模式的一种，是池技术的重要实现方式，它可以减少应用程序创建的对象，降低程序内存的占用，提高程序的性能。 定义：使用共享对象有效...

• ### 在Sequelize中使用迁移

迁移的好处，可以类比git。通过每次创建迁移文件，来支持更新，回滚数据库表结构，也方便协同开发，也避免人工手动去直接修改数据库，用代码自动管理。换个电脑，也不用...

• ### 决策树算法：ID3，C4.5，CART

其实用一下图片能更好的理解LR模型和决策树模型算法的根本区别，我们可以思考一下一个决策问题：是否去相亲，一个女孩的母亲要给这个女海介绍对象。