• 欢迎访问IT乐园(oﾟ▽ﾟ)o
• 推荐使用最新版火狐浏览器和Chrome浏览器访问本网站。

# python之numpy模块

7年前 (2017-04-14) 4148次浏览

## 1)numpy.mat

numpy.mat(data, dtype=None)
Interpret the input as a matrix.

Unlike matrix, asmatrix does not make a copy if the input is already a matrix or an ndarray. Equivalent to matrix(data, copy=False).

```>>> x = np.array([[1, 2], [3, 4]])
>>> m = np.asmatrix(x)
>>> x[0,0] = 5
>>> m
matrix([[5, 2],
[3, 4]])```

## 2)numpy.shape

shape(a)
Return the shape of an array.

Parameters

a : array_like
Input array.

Returns

shape : tuple of ints
The elements of the shape tuple give the lengths of the
corresponding array dimensions.

alen
ndarray.shape : Equivalent array method.

Examples

```>>> np.shape(np.eye(3))
(3, 3)
>>> np.shape([[1, 2]])
(1, 2)
>>> np.shape([0])
(1,)
>>> np.shape(0)
()

>>> a = np.array([(1, 2), (3, 4)], dtype=[('x', 'i4'), ('y', 'i4')])
>>> np.shape(a)
(2,)
>>> a.shape
(2,)```

## 3)numpy.eye

eye(N, M=None, k=0, dtype=<class ‘float’>)
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.

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.]])```

## 4)np.clip

```def clip(a, a_min, a_max, out=None):
"""
Clip (limit) the values in an array.

Given an interval, values outside the interval are clipped to
the interval edges.  For example, if an interval of ``[0, 1]``
is specified, values smaller than 0 become 0, and values larger
than 1 become 1.

Parameters
----------
a : array_like
Array containing elements to clip.
a_min : scalar or array_like
Minimum value.
a_max : scalar or array_like
Maximum value.  If `a_min` or `a_max` are array_like, then they will
be broadcasted to the shape of `a`.
out : ndarray, optional
The results will be placed in this array. It may be the input
array for in-place clipping.  `out` must be of the right shape
to hold the output.  Its type is preserved.

Returns
-------
clipped_array : ndarray
An array with the elements of `a`, but where values
< `a_min` are replaced with `a_min`, and those > `a_max`
with `a_max`.

--------
numpy.doc.ufuncs : Section "Output arguments"

Examples
--------
>>> a = np.arange(10)
>>> np.clip(a, 1, 8)
array([1, 1, 2, 3, 4, 5, 6, 7, 8, 8])
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.clip(a, 3, 6, out=a)
array([3, 3, 3, 3, 4, 5, 6, 6, 6, 6])
>>> a = np.arange(10)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.clip(a, [3,4,1,1,1,4,4,4,4,4], 8)
array([3, 4, 2, 3, 4, 5, 6, 7, 8, 8])

"""```

## 5)numpy.dot

```dot(...)
dot(a, b, out=None)

Dot product of two arrays.

For 2-D arrays it is equivalent to matrix multiplication, and for 1-D
arrays to inner product of vectors (without complex conjugation). For
N dimensions it is a sum product over the last axis of `a` and
the second-to-last of `b`::

dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])

>>> a = [[1,2], [3,4]]
>>> b = [[5,6], [7,8]]
>>> np.dot(a, b)
array([[19, 22],
[43, 50]])
>>> [[1*5+2*7, 1*6+2*8], [3*5+4*7, 3*6+4*8]]
[[19, 22], [43, 50]]

```

## 6)numpy.power

```def power(x1, x2, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__
"""
power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

First array elements raised to powers from second array, element-wise.

Raise each base in `x1` to the positionally-corresponding power in
`x2`.  `x1` and `x2` must be broadcastable to the same shape. Note that an
integer type raised to a negative integer power will raise a ValueError.

Parameters
----------
x1 : array_like
The bases.
x2 : array_like
The exponents.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or `None`,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
where : array_like, optional
Values of True indicate to calculate the ufunc at that position, values
of False indicate to leave the value in the output alone.
**kwargs
For other keyword-only arguments, see the
:ref:`ufunc docs <ufuncs.kwargs>`.

Returns
-------
y : ndarray
The bases in `x1` raised to the exponents in `x2`.

--------
float_power : power function that promotes integers to float

Examples
--------
Cube each element in a list.

>>> x1 = range(6)
>>> x1
[0, 1, 2, 3, 4, 5]
>>> np.power(x1, 3)
array([  0,   1,   8,  27,  64, 125])

Raise the bases to different exponents.

>>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0]
>>> np.power(x1, x2)
array([  0.,   1.,   8.,  27.,  16.,   5.])

>>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]])
>>> x2
array([[1, 2, 3, 3, 2, 1],
[1, 2, 3, 3, 2, 1]])
>>> np.power(x1, x2)
array([[ 0,  1,  8, 27, 16,  5],
[ 0,  1,  8, 27, 16,  5]])
"""```

### 生成从 0 到 100 的 10*10 随机数组

```>>> import numpy as np
>>> np.random.randint(0, 101, size=(10, 10), dtype=int)
array([[96, 16,  5, 40, 82, 19, 88,  5,  0, 40],
[66, 74, 17, 84, 98, 14, 46, 30, 17, 77],
[69, 59, 59, 96, 98, 97, 52, 83, 39, 54],
[86, 39, 46, 45, 76, 29, 15, 69, 71, 41],
[83,  4, 43, 81, 25, 93, 25,  6, 81, 70],
[76, 15, 16, 87, 53, 97, 60, 83, 36, 59],
[85, 19, 49, 17, 34, 70, 23, 20, 98, 59],
[36, 49, 30, 72, 16, 83,  2,  6, 73, 44],
[10,  3, 80, 57, 47, 48, 19,  4, 11, 17],
[ 7, 67, 47, 77, 56, 22, 26, 43, 41, 52]])
```

# （为学习 numpy 持续更新）

IT 乐园 , 版权所有丨如未注明 , 均为原创丨本网站采用BY-NC-SA协议进行授权