Python numpy总结（3）——常用函数用法

a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])
np.ceil(a)# array([-1., -1., -0., 1., 2., 2., 2.])

import numpy as npshuffle_index = np.random.permutation(60000)
X_train, y_train = X_train[shuffle_index], y_train[shuffle_index]

a = np.arange(12)
print('origin a ',a)
np.random.shuffle(a)
print('shuffle a ',a)
print('\n')
a = np.arange(12)
print('origin a ',a)
b = np.random.permutation(a)
print('permutation b ',b)
print('deal with a ',a)'''
origin a [ 0 1 2 3 4 5 6 7 8 9 10 11]
shuffle a [ 5 8 2 10 7 3 0 11 6 9 4 1]origin a [ 0 1 2 3 4 5 6 7 8 9 10 11]
permutation b [ 1 10 2 11 3 7 4 0 8 9 5 6]
deal with a [ 0 1 2 3 4 5 6 7 8 9 10 11]
'''

# some_digit_scores 内容
# array([[-311402.62954431, -363517.28355739, -446449.5306454 ,
# -183226.61023518, -414337.15339485, 161855.74572176,
# -452576.39616343, -471957.14962573, -518542.33997148,
# -536774.63961222]])np.argmax(some_digit_scores)
# Out
# 5

import numpy as npa = np.array([1, 2, 3, 4, 5])
b = np.array([6, 7, 8, 9, 10])
print(np.dot(a, b)) # 130
# 1*6 + 2*7 + 3*8 + 4*9 + 5*10

the shape of a is (5, 5)
the shape of b is (5,)
[73 97 84 95 49]
the shape of np.dot(a,b) is (5,)
[[1 3 3 3 9]
[1 4 8 6 8]
[0 1 7 9 5]
[9 8 4 7 6]
[3 1 1 4 5]]

import numpy as npa = np.random.randint(0, 10, size=(5, 5))
b = np.random.randint(0, 10, size=(5, 3))
print("the shape of a is " + str(a.shape))
print("the shape of b is " + str(b.shape))
print(np.dot(a, b))
'''
the shape of a is (5, 5)
the shape of b is (5, 3)
[[120 162 56]
[ 85 106 80]
[146 99 94]
[ 88 90 70]
[130 87 80]]
'''

X_b = np.c_[np.ones((100, 1)), X] # add x0 = 1 to each instancetheta_best = np.linalg.inv(X_b.T.dot(X_b)).dot(X_b.T).dot(y)

>>> x = np.array([[1.,2.],[3.,4.]])
>>> x
array([[ 1., 2.],
[ 3., 4.]])
>>> x.T
array([[ 1., 3.],
[ 2., 4.]])
>>> x = np.array([1.,2.,3.,4.])
>>> x
array([ 1., 2., 3., 4.])
>>> x.T
array([ 1., 2., 3., 4.])

import numpy as npin:
a = np.ones((3,3))
print(a.shape)
b1 = np.expand_dims(a,2)
print(b1.shape)out:
(2, 2)
(2, 2, 1)note:
b2 = np.expand_dims(a, 0) # (1, 2, 2)
b3 = np.expand_dims(a, 1) # (2, 2, 1)

in:
a = np.ones((2,2,1))
print(a.shape)
b = np.squeeze(a)
print(b.shape)out:
(2, 2, 1)
(2, 2)

random.normal(loc=0.5, scale=1e-2, size=shape)

X_new=np.linspace(-3, 3, 100).reshape(100, 1)
X_new_poly = poly_features.transform(X_new)
y_new = lin_reg.predict(X_new_poly)
plt.plot(X, y, "b.")
plt.plot(X_new, y_new, "r-", linewidth=2, label="Predictions")
plt.xlabel("$x_1$", fontsize=18)
plt.ylabel("$y$", rotation=0, fontsize=18)
plt.legend(loc="upper left", fontsize=14)
plt.axis([-3, 3, 0, 10])
save_fig("quadratic_predictions_plot")
plt.show()

>>> nx, ny = (3, 2)
>>> x = np.linspace(0, 1, nx)
>>> y = np.linspace(0, 1, ny)
>>> xv, yv = np.meshgrid(x, y)
>>> xv
array([[ 0. , 0.5, 1. ],
[ 0. , 0.5, 1. ]])
>>> yv
array([[ 0., 0., 0.],
[ 1., 1., 1.]])
>>> xv, yv = np.meshgrid(x, y, sparse=True) # make sparse output arrays
>>> xv
array([[ 0. , 0.5, 1. ]])
>>> yv
array([[ 0.],
[ 1.]])

t1a, t1b, t2a, t2b = -1, 3, -1.5, 1.5# ignoring bias term
t1s = np.linspace(t1a, t1b, 500)
t2s = np.linspace(t2a, t2b, 500)
t1, t2 = np.meshgrid(t1s, t2s)
T = np.c_[t1.ravel(), t2.ravel()]
Xr = np.array([[-1, 1], [-0.3, -1], [1, 0.1]])
yr = 2 * Xr[:, :1] + 0.5 * Xr[:, 1:]J = (1/len(Xr) * np.sum((T.dot(Xr.T) - yr.T)**2, axis=1)).reshape(t1.shape)N1 = np.linalg.norm(T, ord=1, axis=1).reshape(t1.shape)
N2 = np.linalg.norm(T, ord=2, axis=1).reshape(t1.shape)t_min_idx = np.unravel_index(np.argmin(J), J.shape)
t1_min, t2_min = t1[t_min_idx], t2[t_min_idx]t_init = np.array([[0.25], [-1]])

>>> np.unravel_index([22, 41, 37], (7,6))
(array([3, 6, 6]), array([4, 5, 1]))
>>> np.unravel_index([31, 41, 13], (7,6), order='F')
(array([3, 6, 6]), array([4, 5, 1]))>>> np.unravel_index(1621, (6,7,8,9))
(3, 1, 4, 1)

>>> a = np.array([[1, 2], [3, 4]])
>>> np.mean(a)
2.5
>>> np.mean(a, axis=0)
array([ 2., 3.])
>>> np.mean(a, axis=1)
array([ 1.5, 3.5])>>> a = np.zeros((2, 512*512), dtype=np.float32)
>>> a[0, :] = 1.0
>>> a[1, :] = 0.1
>>> np.mean(a)
0.54999924

def ravel(self, order=None): # real signature unknown; restored from __doc__
"""
a.ravel([order]) Return a flattened array. Refer to `numpy.ravel` for full documentation. See Also
--------
numpy.ravel : equivalent function ndarray.flat : a flat iterator on the array.
"""

import numpy as np
x = np.array([[1, 2], [3,4]])# ravel函数在降维时默认是行序优先
res = x.ravel()
print(x)
print('**************')
print(res)
'''
[[1 2]
[3 4]]
**************
[1 2 3 4]
'''

import numpy as np
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
c = np.c_[a,b]print(np.r_[a,b])
print('*********')
print(np.c_[a,b])
print('*********')
print(np.c_[c,a])
print('*********')
'''
[1 2 3 4 5 6]
*********
[[1 4]
[2 5]
[3 6]]
*********
[[1 4 1]
[2 5 2]
[3 6 3]]
*********
'''

import numpy as npa = np.array([[78, 34, 87, 25, 83], [25, 67, 97, 22, 13], [78, 43, 87, 45, 89]])
print(a.max(axis=0))
print(a.max(axis=1))
'''
[78 67 97 45 89]
[87 97 89]
'''

import numpy as npa = np.array([[[0, 1], [2, 3]], [[4, 5], [6, 7]]])
print(a)
print('**************************')
print(a.max(axis=0))
print('*************************')
print(a.max(axis=1))
print('**************************')
print(a.max(axis=2))
'''
[[[0 1]
[2 3]]
[[4 5]
[6 7]]]
**************************
[[4 5]
[6 7]]
*************************
[[2 3]
[6 7]]
**************************
[[1 3]
[5 7]]
'''

numpy.rollaxis(arr, axis, start)arr：输入数组
axis：要向后滚动的轴，其它轴的相对位置不会改变
start：默认为零，表示完整的滚动。会滚动到特定位置

import numpy as npa = np.arange(8).reshape(2, 2, 2)print('原数组：')
print(a)
print('\n')
# 将轴 2 滚动到轴 0（宽度到深度）print('调用 rollaxis 函数：')
print(np.rollaxis(a, 2))
# 将轴 0 滚动到轴 1：（宽度到高度）
print('\n')print('调用 rollaxis 函数：')
print(np.rollaxis(a, 2, 1))
'''
原数组：
[[[0 1]
[2 3]]
[[4 5]
[6 7]]]
调用 rollaxis 函数：
[[[0 2]
[4 6]]
[[1 3]
[5 7]]]
调用 rollaxis 函数：
[[[0 2]
[1 3]]
'''

where(condition, x=None, y=None)

>>> aa = np.arange(10)
>>> np.where(aa,1,-1)
array([-1, 1, 1, 1, 1, 1, 1, 1, 1, 1]) # 0为False，所以第一个输出-1
>>> np.where(aa > 5,1,-1)
array([-1, -1, -1, -1, -1, -1, 1, 1, 1, 1])>>> np.where([[True,False], [True,True]], # 官网上的例子
[[1,2], [3,4]],
[[9,8], [7,6]])
array([[1, 8],
[3, 4]])

>>> a = 10
>>> np.where([[a > 5,a < 5], [a == 10,a == 7]],
[["chosen","not chosen"], ["chosen","not chosen"]],
[["not chosen","chosen"], ["not chosen","chosen"]])array([['chosen', 'chosen'],
['chosen', 'chosen']], dtype='<U10')

>>> a = np.array([2,4,6,8,10])
>>> np.where(a > 5)# 返回索引
(array([2, 3, 4]),)
>>> a[np.where(a > 5)] # 等价于 a[a>5]
array([ 6, 8, 10])>>> np.where([[0, 1], [1, 0]])
(array([0, 1]), array([1, 0]))

>>> a = np.arange(27).reshape(3,3,3)
>>> a
array([[[ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8]], [[ 9, 10, 11],
[12, 13, 14],
[15, 16, 17]], [[18, 19, 20],
[21, 22, 23],
[24, 25, 26]]])>>> np.where(a > 5)
(array([0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2]),
array([2, 2, 2, 0, 0, 0, 1, 1, 1, 2, 2, 2, 0, 0, 0, 1, 1, 1, 2, 2, 2]),
array([0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2]))# 符合条件的元素为
[ 6, 7, 8]], [[ 9, 10, 11],
[12, 13, 14],
[15, 16, 17]], [[18, 19, 20],
[21, 22, 23],
[24, 25, 26]]]

import numpy as npa = np.array([1, 3, 5, 7, 9])
diff_a = np.diff(a)
print(diff_a)
# [2 2 2 2]

def empty(shape, dtype=None, order='C'): # real signature unknown; restored from __doc__
"""
empty(shape, dtype=float, order='C') Return a new array of given shape and type, without initializing entries. Parameters
----------
shape : int or tuple of int
Shape of the empty array, e.g., ``(2, 3)`` or ``2``.
dtype : data-type, optional
Desired output data-type for the array, e.g, `numpy.int8`. Default is
`numpy.float64`.
order : {'C', 'F'}, optional, default: 'C'
Whether to store multi-dimensional data in row-major
(C-style) or column-major (Fortran-style) order in
memory. Returns
-------
out : ndarray
Array of uninitialized (arbitrary) data of the given shape, dtype, and
order. Object arrays will be initialized to None. See Also
--------
empty_like : Return an empty array with shape and type of input.
ones : Return a new array setting values to one.
zeros : Return a new array setting values to zero.
full : Return a new array of given shape filled with value. Notes
-----
`empty`, unlike `zeros`, does not set the array values to zero,
and may therefore be marginally faster. On the other hand, it requires
the user to manually set all the values in the array, and should be
used with caution. Examples
--------
>>> np.empty([2, 2])
array([[ -9.74499359e+001, 6.69583040e-309],
[ 2.13182611e-314, 3.06959433e-309]]) #random >>> np.empty([2, 2], dtype=int)
array([[-1073741821, -1067949133],
[ 496041986, 19249760]]) #random
"""

a = np.empty((1, 4), dtype=dict)
print(a) # [[None None None None]]
b = np.empty((1, 4), dtype=list)
print(b) # [[None None None None]]

"""
Reverse or permute the axes of an array; returns the modified array. For an array a with two axes, transpose(a) gives the matrix transpose. Parameters
----------
a : array_like
Input array.
axes : tuple or list of ints, optional
If specified, it must be a tuple or list which contains a permutation of
[0,1,..,N-1] where N is the number of axes of a. The i'th axis of the
returned array will correspond to the axis numbered ``axes[i]`` of the
input. If not specified, defaults to ``range(a.ndim)[::-1]``, which
reverses the order of the axes. Returns
-------
p : ndarray
`a` with its axes permuted. A view is returned whenever
possible.
See Also
--------
moveaxis
argsort Notes
-----
Use `transpose(a, argsort(axes))` to invert the transposition of tensors
when using the `axes` keyword argument. Transposing a 1-D array returns an unchanged view of the original array.

import numpy as npt = np.arange(4)
# array([0, 1, 2, 3])
t.transpose()
# array([0, 1, 2, 3])

import numpy as nptwo_array = np.arange(16).reshape(4, 4)
# print(two_array)
'''
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
'''
print(two_array.transpose())
'''
[[ 0 4 8 12]
[ 1 5 9 13]
[ 2 6 10 14]
[ 3 7 11 15]]
'''
print(two_array.transpose(1, 0))
'''
[[ 0 4 8 12]
[ 1 5 9 13]
[ 2 6 10 14]
[ 3 7 11 15]]
'''

import numpy as npthree_array = np.arange(18).reshape(2, 3, 3)
# print(three_array)
'''
[[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]]
[[ 9 10 11]
[12 13 14]
[15 16 17]]]
'''
print(three_array.transpose())
'''
[[[ 0 9]
[ 3 12]
[ 6 15]]
[[ 1 10]
[ 4 13]
[ 7 16]]
[[ 2 11]
[ 5 14]
[ 8 17]]]
'''

#对原始three数组的下标写出来，如下：
A=[
[ [ (0,0,0) , (0,0,1) , (0,0,2)],
[ (0,1,0) , (0,1,1) , (0,1,2)],
[ (0,2,0) , (0,2,1) , (0,2,2)]], [[ (1,0,0) , (1,0,1) , (1,0,2)],
[ (1,1,0) , (1,1,1) , (1,1,2)],
[ (1,2,0) , (1,2,1) , (1,2,2)]]
]#接着把上述每个三元组的第一个数和第三个数进行交换，得到以下的数组B=[[[ (0,0,0) , (1,0,0) , (2,0,0)],
[ (0,1,0) , (1,1,0) , (2,1,0)],
[ (0,2,0) , (1,2,0) , (2,2,0)]], [[ (0,0,1) , (1,0,1) , (2,0,1)],
[ (0,1,1) , (1,1,1) , (2,1,1)],
[ (0,2,1) , (1,2,1) , (2,2,1)]]]#最后在原数组中把B对应的下标的元素，写到相应的位置
#对比看一下，这是原数组
[[[ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8]], [[ 9, 10, 11],
[12, 13, 14],
[15, 16, 17]]]
# 按照B的映射关系得到最终的数组。
C=[[[ 0, 9],
[ 3, 12],
[ 6, 15]], [[ 1, 10],
[4, 13],
[7, 16]] [[ 2, 11],
[5, 14],
[8, 17]]
]
# 最终的结果也就是数组C

import cv2 as cv
import numpy as npimg = cv.imread('my.jpg')
cv.imshow('img',img)
#逆时针旋转90度
img = np.transpose(img, (1, 0, 2))
#顺时针旋转90度
# img = cv.flip(img, 1)
#顺时针旋转270度
# img = cv.flip(img, 1)
cv.namedWindow('img',cv.WINDOW_AUTOSIZE)
cv.imshow('img2',img)
cv.waitKey(0)
cv.destroyAllWindows()

def rot90(m, k=1, axes=(0, 1)):
"""
Rotate an array by 90 degrees in the plane specified by axes. Rotation direction is from the first towards the second axis. Parameters
----------
m : array_like
Array of two or more dimensions.
k : integer
Number of times the array is rotated by 90 degrees.
axes: (2,) array_like
The array is rotated in the plane defined by the axes.
Axes must be different. .. versionadded:: 1.12.0 Returns
-------
y : ndarray
A rotated view of `m`. See Also
--------
flip : Reverse the order of elements in an array along the given axis.
fliplr : Flip an array horizontally.
flipud : Flip an array vertically. Notes
-----
rot90(m, k=1, axes=(1,0)) is the reverse of rot90(m, k=1, axes=(0,1))
rot90(m, k=1, axes=(1,0)) is equivalent to rot90(m, k=-1, axes=(0,1))

>>> m = np.array([[1,2],[3,4]], int)
>>> m
array([[1, 2],
[3, 4]])
>>> np.rot90(m)
array([[2, 4],
[1, 3]])
>>> np.rot90(m, 2)
array([[4, 3],
[2, 1]])
>>> m = np.arange(8).reshape((2,2,2))
>>> np.rot90(m, 1, (1,2))
array([[[1, 3],
[0, 2]],
[[5, 7],
[4, 6]]])

from PIL import Imageimg = Image.open("logo1.jpg")# 旋转方式一
img1 = img.transpose(Image.ROTATE_90) # 引用固定的常量值
img1.save("r1.jpg")# 旋转方式二
img2 = img.rotate(90) # 自定义旋转度数
img2.save("r2.jpg")# np 旋转方式
img3 = cv2.imread("logo1.jpg")
img3 = np.rot90(img3, k=1)
cv2.imwrite("r3.jpg", img3)