Mars_sock

Numpy基本用法

文章目录

一、Numpy基本用法
二、Numpy创建数组

1.使用np.array()由python list创建
2.使用np的routines函数创建

2.1 np.ones()
2.2 zeros()
2.3 np.full()
2.4 np.eye()
2.5 np.linspace()
2.6 arange()
2.7 randint()
2.8 randn() 正太分布
2.9 normal() 正太分布
2.10 random_sample() 生成0到1的随机数

三、Numpy查看数组属性

1.数组元素个数
2.数组形状
3.数组维度
4.数组元素类型

四、数组的基本操作

1.索引
2.切片
3.变形
4.级联

np.hstack与np.vstack

5.切分
6.副本

五、Numpy计算

条件运算
统计运算
数组运算
矩阵运算np.dot()
矩阵的广播

六、排序

1.快速排序
2.部分排序
numpy案例

一、Numpy基本用法

NumPy是Python语言的一个扩充程序库。支持高级大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。Numpy内部解除了Python的PIL(全局解释器锁),运算效率极好,是大量机器学习框架的基础库!

#导入numpy库，并查看numpy库版本
In [1]: import numpy as np

In [2]: np.__version__
Out[2]: '1.14.3'

#利用numpy+matplotlib处理图片
In [7]: import matplotlib.pyplot as plt

In [8]: cat = plt.imread('D:\myProject\Python\Jupyter\image\cat.jpg')

In [9]: type(cat)
Out[9]: numpy.ndarray

In [10]: cat1 = cat -50

#图片是一个三维数组，长、宽、颜色
In [11]: cat.shape
Out[11]: (333, 500, 3)

In [12]: plt.imshow(cat1)
Out[12]: <matplotlib.image.AxesImage at 0x222924b0320>
In [13]: plt.show()

二、Numpy创建数组

1.使用np.array()由python list创建

In [14]: import numpy as np
#创建列表
In [15]: a = [1,2,3,4,5]
#将列表转换为数组
In [16]: b = np.array(a)

In [17]: b
Out[17]: array([1, 2, 3, 4, 5])

2.使用np的routines函数创建

2.1 np.ones()

# 1、np.ones(shape, dtype=None, order='C')
In [18]: np.ones(shape = (10,8),dtype= int)
Out[18]:
array([[1, 1, 1, 1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1, 1, 1, 1]])

In [19]: ones = np.ones(shape=(100,90,4),dtype=int)

In [20]: plt.imshow(ones)
    ...: plt.show()

2.2 zeros()

# 2、zeros(shape, dtype=float, order='C')
In [21]: np.zeros((4,4))
Out[21]:
array([[0., 0., 0., 0.],
       [0., 0., 0., 0.],
       [0., 0., 0., 0.],
       [0., 0., 0., 0.]])

2.3 np.full()

# 3、 np.full(shape, fill_value, dtype=None, order='C')
In [22]: np.full((10,10),fill_value=20)
Out[22]:
array([[20, 20, 20, 20, 20, 20, 20, 20, 20, 20],
       [20, 20, 20, 20, 20, 20, 20, 20, 20, 20],
       [20, 20, 20, 20, 20, 20, 20, 20, 20, 20],
       [20, 20, 20, 20, 20, 20, 20, 20, 20, 20],
       [20, 20, 20, 20, 20, 20, 20, 20, 20, 20],
       [20, 20, 20, 20, 20, 20, 20, 20, 20, 20],
       [20, 20, 20, 20, 20, 20, 20, 20, 20, 20],
       [20, 20, 20, 20, 20, 20, 20, 20, 20, 20],
       [20, 20, 20, 20, 20, 20, 20, 20, 20, 20],
       [20, 20, 20, 20, 20, 20, 20, 20, 20, 20]])

2.4 np.eye()

# 4、np.eye(N, M=None, k=0, dtype=, order='C')
#对角线位1，其他位置位0
In [23]: np.eye(10)
Out[23]:
array([[1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 1.]])

2.5 np.linspace()

# 5、np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
#lin = linear 线性
In [24]: np.linspace(1,100,20)
Out[24]:
array([  1.        ,   6.21052632,  11.42105263,  16.63157895,
        21.84210526,  27.05263158,  32.26315789,  37.47368421,
        42.68421053,  47.89473684,  53.10526316,  58.31578947,
        63.52631579,  68.73684211,  73.94736842,  79.15789474,
        84.36842105,  89.57894737,  94.78947368, 100.        ])

2.6 arange()

# 6、arange([start,] stop[, step,], dtype=None)
In [25]: np.arange(0,10,2)
Out[25]: array([0, 2, 4, 6, 8])

2.7 randint()

# 7、randint(low, high=None, size=None, dtype='l')
In [26]: np.random.randint(0,10,size = 10)
Out[26]: array([0, 9, 8, 9, 5, 5, 2, 6, 8, 7])

2.8 randn() 正太分布

# 8、randn(d0, d1, ..., dn)  正太分布
In [27]: np.random.randn(4,5)
Out[27]:
array([[ 1.05035386,  0.77231903, -0.33446991, -0.54562315, -0.84341866],
       [ 0.6616944 ,  0.89325969, -0.89042489,  1.61227272, -0.05136764],
       [-0.5346068 , -2.39236557, -0.54563468, -1.07850467,  0.56603284],
       [-0.33361988,  1.11445864, -0.11636709,  0.57361067,  0.80099792]])

2.9 normal() 正太分布

# 9、normal(loc=0.0, scale=1.0, size=None) 正太分布
In [28]: np.random.normal(loc=170,scale=1,size=20)
Out[28]:
array([168.56872023, 168.30641964, 169.98891802, 168.6781631 ,
       169.63611345, 167.81502056, 169.69833366, 169.05166886,
       170.96688262, 168.30677654, 170.15970816, 169.59783795,
       170.77979873, 170.20138558, 169.75464312, 172.16309013,
       169.37900208, 171.23951841, 169.7903996 , 168.62081606])

2.10 random_sample() 生成0到1的随机数

# 10、random_sample(size=None) 生成0到1的随机数
#np.random.random(size=20)
In [29]: r = np.random.random(size=(200,100,4)) #生成一张图片

In [30]: plt.imshow(r)
Out[30]: <matplotlib.image.AxesImage at 0x22293b60dd8>

In [31]: plt.show()

三、Numpy查看数组属性

1.数组元素个数

In [33]: b
Out[33]: array([1, 2, 3, 4, 5])

In [34]: b.size
Out[34]: 5

2.数组形状

In [35]: b.shape
Out[35]: (5,)

3.数组维度

In [36]: b.ndim
Out[36]: 1

4.数组元素类型

In [37]: b.dtype
Out[37]: dtype('int32')

四、数组的基本操作

1.索引

In [39]: array1 = np.random.randint(0,100,(4,4))

In [40]: array1
Out[40]:
array([[85, 18, 96, 92],
       [42, 49, 76, 85],
       [42,  1, 80, 99],
       [33, 91, 74, 95]])

In [41]: array1[0,1]
Out[41]: 18

2.切片

#切片时，左闭右开
In [42]: array1[1:3,2:4]
Out[42]:
array([[76, 85],
       [80, 99]])

In [43]: array2 = np.arange(0,10)

In [44]: array2
Out[44]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

#将数组反转
In [45]: array2[::-1]
Out[45]: array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])

#通过两个：：进行切片
In [46]: print(array2[::2])
[0 2 4 6 8]

In [47]: print(array2[::-2])
[9 7 5 3 1]

3.变形

使用reshape函数，注意参数用tuple

In [48]: import numpy as np

In [49]: n = np.arange(0,10)

In [50]: n
Out[50]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

In [51]: n.shape
Out[51]: (10,)

#使用reshape函数进行变形
In [52]: n.reshape((5,2))
Out[52]:
array([[0, 1],
       [2, 3],
       [4, 5],
       [6, 7],
       [8, 9]])

In [53]: n1 = np.random.randint(0,100,(3,4,5))

In [54]: n1
Out[54]:
array([[[48,  8,  2, 35, 65],
        [81, 56, 20, 85, 76],
        [94, 65, 62, 59, 78],
        [48, 57,  7,  3, 63]],

       [[56, 27,  4, 21, 28],
        [92, 10, 73, 63, 82],
        [88, 28, 10, 76, 99],
        [49,  6, 39, 21, 50]],

       [[84, 87, 65, 15, 52],
        [94, 44, 40,  2, 94],
        [ 7, 90, 78, 18, 94],
        [94, 64, 83, 54,  6]]])

In [55]: n1.shape
Out[55]: (3, 4, 5)

In [56]: n1.reshape(3*4*5)
Out[56]:
array([48,  8,  2, 35, 65, 81, 56, 20, 85, 76, 94, 65, 62, 59, 78, 48, 57,
        7,  3, 63, 56, 27,  4, 21, 28, 92, 10, 73, 63, 82, 88, 28, 10, 76,
       99, 49,  6, 39, 21, 50, 84, 87, 65, 15, 52, 94, 44, 40,  2, 94,  7,
       90, 78, 18, 94, 94, 64, 83, 54,  6])

#使用负数直接转换成一维数组
In [57]: n1.reshape(-1)
Out[57]:
array([48,  8,  2, 35, 65, 81, 56, 20, 85, 76, 94, 65, 62, 59, 78, 48, 57,
        7,  3, 63, 56, 27,  4, 21, 28, 92, 10, 73, 63, 82, 88, 28, 10, 76,
       99, 49,  6, 39, 21, 50, 84, 87, 65, 15, 52, 94, 44, 40,  2, 94,  7,
       90, 78, 18, 94, 94, 64, 83, 54,  6])

4.级联

np.concatenate()级联需要注意的点：
- 1.级联的参数是列表：一定要加中括号或小括号
- 2.维度必须相同
- 3.形状相符
- 4.【重点】级联的方向默认是shape这个tuple的第一个值所代表的维度方向
- 5.可通过axis参数改变级联的方向

In [58]: import numpy as np

In [59]: n1 = np.random.randint(0,10,(5,5))

In [60]: n1
Out[60]:
array([[1, 0, 1, 3, 2],
       [0, 1, 9, 2, 9],
       [2, 4, 1, 1, 1],
       [5, 2, 2, 6, 2],
       [8, 8, 8, 7, 2]])
#列级联
In [61]: np.concatenate((n1,n1),axis = 0)
Out[61]:
array([[1, 0, 1, 3, 2],
       [0, 1, 9, 2, 9],
       [2, 4, 1, 1, 1],
       [5, 2, 2, 6, 2],
       [8, 8, 8, 7, 2],
       [1, 0, 1, 3, 2],
       [0, 1, 9, 2, 9],
       [2, 4, 1, 1, 1],
       [5, 2, 2, 6, 2],
       [8, 8, 8, 7, 2]])
#行级联
In [62]: np.concatenate((n1,n1),axis = 1)
Out[62]:
array([[1, 0, 1, 3, 2, 1, 0, 1, 3, 2],
       [0, 1, 9, 2, 9, 0, 1, 9, 2, 9],
       [2, 4, 1, 1, 1, 2, 4, 1, 1, 1],
       [5, 2, 2, 6, 2, 5, 2, 2, 6, 2],
       [8, 8, 8, 7, 2, 8, 8, 8, 7, 2]])

np.hstack与np.vstack

水平级联与垂直级联，处理自己。进行维度的变更

In [63]: n2 = np.random.randint(0,100,size=10)

In [64]: n2
Out[64]: array([73, 65, 92, 23, 32, 47, 78, 83, 97, 37])

#vertical 垂直
In [65]: n3 = np.vstack(n2) 
                            
In [66]: print(n3.shape)    
(10, 1)                     
                            
In [67]: n3                 
Out[67]:                    
array([[73],                
       [65],                
       [92],                
       [23],                
       [32],                
       [47],                
       [78],                
       [83],                
       [97],                
       [37]])

# 水平
In [68]: n4 = np.array([[1,2,3,4,5],[6,7,8,9]])

In [69]: n4
Out[69]: array([list([1, 2, 3, 4, 5]), list([6, 7, 8, 9])], dtype=object)

In [70]: np.hstack(n4)
Out[70]: array([1, 2, 3, 4, 5, 6, 7, 8, 9])

In [71]: np.hstack(n3)
Out[71]: array([73, 65, 92, 23, 32, 47, 78, 83, 97, 37])

5.切分

与级联类似，常用函数：
- np.split
- np.vsplit
- np.hsplit

In [72]: n5 = np.random.randint(0,150,size=(5,7))

In [73]: n5
Out[73]:
array([[122, 102,  37,  69,  28, 102, 131],
       [ 48,  84,  27, 119,   7,  65,  61],
       [ 17, 125, 142, 145, 132,  21,  57],
       [ 96,  23,  72,  45,  77,  54,  65],
       [120,  31, 104, 132,  64,  72, 145]])

In [74]: np.split(n5,(1,3))
Out[74]:
[array([[122, 102,  37,  69,  28, 102, 131]]),
 array([[ 48,  84,  27, 119,   7,  65,  61],
        [ 17, 125, 142, 145, 132,  21,  57]]),
 array([[ 96,  23,  72,  45,  77,  54,  65],
        [120,  31, 104, 132,  64,  72, 145]])]

#水平切分，即按行进行切分
In [75]: np.split(n5,(1,3),axis=1)
Out[75]:
[array([[122],
        [ 48],
        [ 17],
        [ 96],
        [120]]), array([[102,  37],
        [ 84,  27],
        [125, 142],
        [ 23,  72],
        [ 31, 104]]), array([[ 69,  28, 102, 131],
        [119,   7,  65,  61],
        [145, 132,  21,  57],
        [ 45,  77,  54,  65],
        [132,  64,  72, 145]])]

In [76]: np.split(n5,(1,3))[1]
Out[76]:
array([[ 48,  84,  27, 119,   7,  65,  61],
       [ 17, 125, 142, 145, 132,  21,  57]])

In [81]: cat.shape
Out[81]: (333, 500, 3)
    
In [77]: import matplotlib.pyplot as plt

In [78]: cat1 = np.split(cat,(100,200))[1]

In [79]: plt.imshow(cat1)
Out[79]: <matplotlib.image.AxesImage at 0x22293e9b978>

In [80]: plt.show()

#垂直切分
In [82]: np.vsplit(n5,(1,3))
Out[82]:
[array([[122, 102,  37,  69,  28, 102, 131]]),
 array([[ 48,  84,  27, 119,   7,  65,  61],
        [ 17, 125, 142, 145, 132,  21,  57]]),
 array([[ 96,  23,  72,  45,  77,  54,  65],
        [120,  31, 104, 132,  64,  72, 145]])]

#水平切分
In [83]: np.hsplit(n5,(1,3))
Out[83]:
[array([[122],
        [ 48],
        [ 17],
        [ 96],
        [120]]), array([[102,  37],
        [ 84,  27],
        [125, 142],
        [ 23,  72],
        [ 31, 104]]), array([[ 69,  28, 102, 131],
        [119,   7,  65,  61],
        [145, 132,  21,  57],
        [ 45,  77,  54,  65],
        [132,  64,  72, 145]])]

6.副本

所有赋值运算不会为ndarray的任何元素创建副本，对赋值后的对象的操作也对原来的对象生效。

In [84]: a = [x for x in range(5)]

In [85]: n = np.array(a)

In [86]: n
Out[86]: array([0, 1, 2, 3, 4])

In [87]: n[2] = 512

In [88]: n
Out[88]: array([  0,   1, 512,   3,   4])

#当数据是ndarray,用=赋值，内存没有改变
In [89]: n2 = n

In [90]: n2[2] = 1024

In [91]: display(n,n2)
array([   0,    1, 1024,    3,    4])
array([   0,    1, 1024,    3,    4])

使用copy()函数创建副本

In [92]: n3 = n.copy()

In [93]: n3
Out[93]: array([   0,    1, 1024,    3,    4])

In [94]: n3[2] = 0

In [95]: display(n,n3)
array([   0,    1, 1024,    3,    4])
array([0, 1, 0, 3, 4])

五、Numpy计算

条件运算

# 条件判断
In [97]: stus_score = np.array([[80,88],[82,81],[84,75],[86,83],[75,81]])

In [98]: stus_score > 80
Out[98]:
array([[False,  True],
       [ True,  True],
       [ True, False],
       [ True,  True],
       [False,  True]])

# 三目运算（如果数值小于80，替换为0，如果大于80，替换为90）
In [100]: stus_score = np.array([[80, 88], [82, 81], [84, 75], [86, 83], [75, 81]])

In [101]: np.where(stus_score < 80, 0, 90)
Out[101]:
array([[90, 90],
       [90, 90],
       [90,  0],
       [90, 90],
       [ 0, 90]])

统计运算

# 指定轴最大值amax(参数1: 数组; 参数2: axis=0/1; 0表示列1表示行)
stus_score = np.array([[80, 88], [82, 81], [84, 75], [86, 83], [75, 81]])
# 求每一列的最大值(0表示列)
In [106]: print("每一行的最大值为:")
每一行的最大值为:

In [107]: print("每一列的最大值为:")
     ...: result = np.amax(stus_score, axis=0)
     ...: print(result)
     ...: print("每一行的最大值为:")
     ...: result = np.amax(stus_score, axis=1)
     ...: print(result)
     ...:
     ...:
每一列的最大值为:
[86 88]
每一行的最大值为:
[88 82 84 86 81]

# 指定轴最大值amax(参数1: 数组; 参数2: axis=0/1/2;分别对应各个维度)
In [108]: import numpy as np

In [109]: n = np.random.randint(0,150,(4,4,4))

In [110]: n
Out[110]:
array([[[ 91,  45,  10,  51],
        [102,  88, 129, 100],
        [148,  72,  52, 114],
        [ 99,   5,  67,  26]],

       [[ 23, 102, 125, 116],
        [140,  61, 107,  15],
        [ 39, 125, 139,  38],
        [ 95, 148, 100, 109]],

       [[ 92,  68, 140,  75],
        [ 49, 113,  68,  70],
        [149, 107,  78,  69],
        [120, 109,  27, 138]],

       [[126,  79, 113,  89],
        [ 29, 126,   3,  90],
        [ 40,  23,  20,  14],
        [ 72,  38,  99,  55]]])

In [111]: n.max(axis=0)
Out[111]:
array([[126, 102, 140, 116],
       [140, 126, 129, 100],
       [149, 125, 139, 114],
       [120, 148, 100, 138]])

In [112]: n.max(axis=1)
Out[112]:
array([[148,  88, 129, 114],
       [140, 148, 139, 116],
       [149, 113, 140, 138],
       [126, 126, 113,  90]])

In [113]: n.max(axis=2)
Out[113]:
array([[ 91, 129, 148,  99],
       [125, 140, 139, 148],
       [140, 113, 149, 138],
       [126, 126,  40,  99]])

# 指定轴最小值amin
In [114]: stus_score = np.array([[80, 88], [82, 81], [84, 75], [86, 83], [75, 81]])
# 求每一行的最小值(0表示列)
In [115]: print("每一列的最小值为:")
     ...: result = np.amin(stus_score, axis=0)
     ...: print(result)
     ...:
     ...: # 求每一行的最小值(1表示行)
     ...: print("每一行的最小值为:")
     ...: result = np.amin(stus_score, axis=1)
     ...: print(result)
     ...:
     ...:
每一列的最小值为:
[75 75]
每一行的最小值为:
[80 81 75 83 75]

# 指定轴平均值mean
In [116]: stus_score = np.array([[80, 88], [82, 81], [84, 75], [86, 83], [75, 81]])
In [117]: # 求每一行的平均值(0表示列)
     ...: print("每一列的平均值:")
     ...: result = np.mean(stus_score, axis=0)
     ...: print(result)
     ...:
     ...: # 求每一行的平均值(1表示行)
     ...: print("每一行的平均值:")
     ...: result = np.mean(stus_score, axis=1)
     ...: print(result)
     ...:
     ...:
每一列的平均值:
[81.4 81.6]
每一行的平均值:
[84.  81.5 79.5 84.5 78.]

# 方差std
In [118]: stus_score = np.array([[80, 88], [82, 81], [84, 75], [86, 83], [75, 81]])

In [119]: # 求每一行的方差(0表示列)
     ...: print("每一列的方差:")
     ...: result = np.std(stus_score, axis=0)
     ...: print(result)
     ...:
     ...: # 求每一行的方差(1表示行)
     ...: print("每一行的方差:")
     ...: result = np.std(stus_score, axis=1)
     ...: print(result)
     ...:
     ...:
每一列的方差:
[3.77359245 4.1761226 ]
每一行的方差:
[4.  0.5 4.5 1.5 3. ]

数组运算

# 数组与数的运算
In [120]: import numpy as np

In [121]: stus_score = np.array([[80, 88], [82, 81], [84, 75], [86, 83], [75, 81]])

In [122]: print("加之前：")
     ...: print(stus_score)
     ...:
     ...: #为所有平时成绩都加5分
     ...: stus_score[:,0]=stus_score[:,0]+5
     ...: print("加之后：")
     ...: print(stus_score)
     ...:
     ...:
加之前：
[[80 88]
 [82 81]
 [84 75]
 [86 83]
 [75 81]]
加之后：
[[85 88]
 [87 81]
 [89 75]
 [91 83]
 [80 81]]

# 数组也支持加减乘除运算
In [123]: import numpy as np

In [124]: a = np.array([1,2,3,4])
     ...: b = np.array([10,20,30,40])
     ...: c = a + b
     ...: d = a - b
     ...: e = a * b
     ...: f = a / b
     ...: print("a+b=",c)
     ...: print("a-b=",d)
     ...: print("a*b=",e)
     ...: print("a/b=",f)
     ...:
     ...:
a+b= [11 22 33 44]
a-b= [ -9 -18 -27 -36]
a*b= [ 10  40  90 160]
a/b= [0.1 0.1 0.1 0.1]

矩阵运算np.dot()

# 计算规则(计算学生总成绩)
#（M行，N列）*（N行，Z列）=（M行，Z列）
In [125]: import numpy as np

In [126]: stus_score = np.array([[80, 88], [82, 81], [84, 75], [86, 83], [75, 81]])
     ...: #平时成绩占40%,期末成绩占60%,计算结果
     ...: q = np.array([[0.4],[0.6]])
     ...: result = np.dot(stus_score,q)
     ...: print("最终结果为：")
     ...: print(result)
     ...:
     ...:
最终结果为：
[[84.8]
 [81.4]
 [78.6]
 [84.2]
 [78.6]]

# 矩阵拼接
## 矩阵垂直拼接
In [127]: print("v1为:")
     ...: v1 = [[0, 1, 2, 3, 4, 5],
     ...:       [6, 7, 8, 9, 10, 11]]
     ...: print(v1)
     ...: print("v2为:")
     ...: v2 = [[12, 13, 14, 15, 16, 17],
     ...:       [18, 19, 20, 21, 22, 23]]
     ...: print(v2)
     ...:
v1为:
[[0, 1, 2, 3, 4, 5], [6, 7, 8, 9, 10, 11]]
v2为:
[[12, 13, 14, 15, 16, 17], [18, 19, 20, 21, 22, 23]]

# 垂直拼接
In [128]: result = np.vstack((v1, v2))
     ...: print("v1和v2垂直拼接的结果为")
     ...: print(result)
     ...:
     ...:
v1和v2垂直拼接的结果为
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]

# 矩阵水平拼接
In [129]: print("v1为:")
     ...: v1 = [[0, 1, 2, 3, 4, 5],
     ...:       [6, 7, 8, 9, 10, 11]]
     ...: print(v1)
     ...: print("v2为:")
     ...: v2 = [[12, 13, 14, 15, 16, 17],
     ...:       [18, 19, 20, 21, 22, 23]]
     ...: print(v2)
     ...:
v1为:
[[0, 1, 2, 3, 4, 5], [6, 7, 8, 9, 10, 11]]
v2为:
[[12, 13, 14, 15, 16, 17], [18, 19, 20, 21, 22, 23]]

# 垂直拼接
In [130]: result = np.hstack((v1, v2))
     ...: print("v1和v2水平拼接的结果为")
     ...: print(result)
     ...:
     ...:
v1和v2水平拼接的结果为
[[ 0  1  2  3  4  5 12 13 14 15 16 17]
 [ 6  7  8  9 10 11 18 19 20 21 22 23]]

矩阵的广播

ndarray广播的两条规则：
- 规则一：为缺失的维度补1
- 规则二：假定缺失元素用已有值填充

#实例1：m = np.ones((2,3)) a = np.arange(3)求m+a
In [131]: import numpy as np

In [132]: m = np.ones((2,3))
     ...: a = np.arange(3)
     ...: display(m,a)
     ...:
     ...:
array([[1., 1., 1.],
       [1., 1., 1.]])
array([0, 1, 2])

#numpy广播，维度不同，自动补全
In [133]: m + a
Out[133]:
array([[1., 2., 3.],
       [1., 2., 3.]])

#实例2：a = np.arange(3).reshape((3,1)) b = np.arange(3) 求a+b
In [134]: a = np.arange(3).reshape((3,1))
     ...: b = np.arange(3)
     ...: display(a,b)
     ...:
     ...:
array([[0],
       [1],
       [2]])
array([0, 1, 2])

In [135]: a + b
Out[135]:
array([[0, 1, 2],
       [1, 2, 3],
       [2, 3, 4]])

六、排序

1.快速排序

np.sort()与ndarray.sort()，区别:
- np.sort()不改变输入
- ndarray.sort()本地处理，不占用空间，改变输入

In [136]: n1 = np.random.randint(0,150,size=15)

In [137]: n1
Out[137]:
array([ 80,  11,  31,  68,  83,  73,  42,   6,  40, 125, 147, 147,  88,
       117,  85])

In [138]: n2 = n1.sort()

In [139]: display(n1,n2)
array([  6,  11,  31,  40,  42,  68,  73,  80,  83,  85,  88, 117, 125,
       147, 147])
None

In [140]: n3 = np.sort(n1)
     ...: display(n1,n3)
     ...:
     ...:
array([  6,  11,  31,  40,  42,  68,  73,  80,  83,  85,  88, 117, 125,
       147, 147])
array([  6,  11,  31,  40,  42,  68,  73,  80,  83,  85,  88, 117, 125,
       147, 147])

2.部分排序

np.partition(a,k)
- 当k为正时：我们想要得到最小的k个数
- 当k为负时：我们想要得到最大的k个数

In [141]: n4 = np.random.randint(0,150,size=20)

In [142]: n4
Out[142]:
array([ 37,  74,  41,  53,  31,  11,  23, 108,  12, 128,  27,  88,  74,
       114,  97, 127,  60,  47, 130, 135])

In [143]: np.partition(n4,-5)
Out[143]:
array([ 37,  12,  41,  27,  31,  11,  23,  47,  74,  60,  53,  74,  88,
        97, 108, 114, 127, 128, 130, 135])

In [144]: np.partition(n4,5)
Out[144]:
array([ 12,  23,  11,  27,  31,  37,  41,  47, 108,  74,  53,  88,  74,
       114,  97, 127,  60, 128, 130, 135])

#取数组中最大的k个数
In [145]: np.partition(n4,-2)[-2:]
Out[145]: array([130, 135])

numpy案例

使用numpy将图片进行翻转

import matplotlib.pyplot as plt
import numpy as np
%matplotlib inline

dianxin = plt.imread('./image/dianxin.jpg')
plt.imshow(dianxin)

#将图片在竖直方向翻转
dianxin1 = dianxin[::-1]
plt.imshow(dianxin1)

#在水平方向翻转
dianxin2 = dianxin[::,::-1]
plt.imshow(dianxin2)

# 即在水平方向翻转又在垂直方向翻转
dianxin3 = dianxin[::-1,::-1]
plt.imshow(dianxin3)

# 改变图片颜色
dianxin4 = dianxin[::,::,-2]
plt.imshow(dianxin4)

#修改图片，是图片模糊
dianxin5 = dianxin[::3,::3]
plt.imshow(dianxin5)

你可能感兴趣的:(Python,numpy)

理解Gunicorn：Python WSGI服务器的基石范范0825 ipython linux 运维
理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
Python数据分析与可视化实战指南 William数据分析 python python 数据
在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
python os.environ 江湖偌大 python 深度学习
os.environ['TF_CPP_MIN_LOG_LEVEL']='0'#默认值，输出所有信息os.environ['TF_CPP_MIN_LOG_LEVEL']='1'#屏蔽通知信息（INFO）os.environ['TF_CPP_MIN_LOG_LEVEL']='2'#屏蔽通知信息和警告信息（INFO\WARNING）os.environ['TF_CPP_MIN_LOG_LEVEL']='
Python中os.environ基本介绍及使用方法鹤冲天Pro #Python python 服务器开发语言
文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
Pyecharts数据可视化大屏：打造沉浸式数据分析体验我的运维人生信息可视化数据分析数据挖掘运维开发技术共享
Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
Python教程：一文了解使用Python处理XPath 旦莫 Python进阶 python 开发语言
目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
python os.environ_python os.environ 读取和设置环境变量 weixin_39605414 python os.environ
>>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
使用Faiss进行高效相似度搜索 llzwxh888 faiss python
在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
python是什么意思中文-在python中%是什么意思编程大乐趣
Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Python python 开发语言大数据数据分析数据挖掘
大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
python八股文面试题分享及解析(1) Shawn________ python
#1.'''a=1b=2不用中间变量交换a和b'''#1.a=1b=2a,b=b,aprint(a)print(b)结果：21#2.ll=[]foriinrange(3):ll.append({'num':i})print(11)结果:#[{'num':0},{'num':1},{'num':2}]#3.kk=[]a={'num':0}foriinrange(3):#0,12#可变类型，不仅仅改变
每日算法&面试题，大厂特训二十八天——第二十天（树）肥学 ⚡算法题⚡面试题每日精进 java 算法数据结构
目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
Python快速入门 —— 第三节：类与对象孤华暗香 Python快速入门 python 开发语言
第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
pyecharts——绘制柱形图折线图 2224070247 信息可视化 python java 数据可视化
一、pyecharts概述自2013年6月百度EFE(ExcellentFrontEnd）数据可视化团队研发的ECharts1.0发布到GitHub网站以来，ECharts一直备受业界权威的关注并获得广泛好评，成为目前成熟且流行的数据可视化图表工具，被应用到诸多数据可视化的开发领域。Python作为数据分析领域最受欢迎的语言，也加入ECharts的使用行列，并研发出方便Python开发者使用的数据
Python 实现图片裁剪（附代码） | Python工具剑客阿良_ALiang
前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
【华为OD技术面试真题 - 技术面】- python八股文真题题库（4) 算法大师华为od 面试 python
华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
python os 环境变量 CV矿工 python 开发语言 numpy
环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
Python爬虫解析工具之xpath使用详解 eqa11 python 爬虫开发语言
文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
【华为OD技术面试真题 - 技术面】- python八股文真题题库（1）算法大师华为od 面试 python
华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
nosql数据库技术与应用知识点皆过客，揽星河 NoSQL nosql 数据库大数据数据分析数据结构非关系型数据库
Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
《Python数据分析实战终极指南》 xjt921122 python 数据分析开发语言
对于分析师来说，大家在学习Python数据分析的路上，多多少少都遇到过很多大坑**，有关于技能和思维的**：Excel已经没办法处理现有的数据量了，应该学Python吗？找了一大堆Python和Pandas的资料来学习，为什么自己动手就懵了？跟着比赛类公开数据分析案例练了很久，为什么当自己面对数据需求还是只会数据处理而没有分析思路？学了对比、细分、聚类分析，也会用PEST、波特五力这类分析法，为啥
Python中深拷贝与浅拷贝的区别 yuxiaoyu.
转自：http://blog.csdn.net/u014745194/article/details/70271868定义：在Python中对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复
Python开发常用的三方模块如下：换个网名有点难 python 开发语言
Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
Python编译器鹿鹿~ Python编译器 Python python 开发语言后端
嘿嘿嘿我又来了啊有些小盆友可能不知道Python其实是有编译器的，也就是PyCharm。你们可能会问到这个是干嘛的又不可以吃也不可以穿好像没有什么用，其实你还说对了这个还真的不可以吃也不可以穿，但是它用来干嘛的呢。用来编译你所打出的代码进行运行（可能这里说的有点不对但是只是个人认为）现在我们来说说PyCharm是用来干嘛的。PyCharm是一种PythonIDE，带有一整套可以帮助用户在使用Pyt
一文掌握python面向对象魔术方法（二）程序员neil python python 开发语言
接上篇：一文掌握python面向对象魔术方法（一）-CSDN博客目录六、迭代和序列化：1、__iter__(self):定义迭代器，使得类可以被for循环迭代。2、__getitem__(self,key):定义索引操作，如obj[key]。3、__setitem__(self,key,value):定义赋值操作，如obj[key]=value。4、__delitem__(self,key):定义
一文掌握python常用的list（列表）操作程序员neil python python 开发语言
目录一、创建列表1.直接创建列表：2.使用list()构造器3.使用列表推导式4.创建空列表二、访问列表元素1.列表支持通过索引访问元素，索引从0开始：2.还可以使用切片操作访问列表的一部分：三、修改列表元素四、添加元素1.append()：在末尾添加元素2.insert()：在指定位置插入元素五、删除元素1.del：删除指定位置的元素2.remove()：删除指定值的第一个匹配项3.pop()：
Python实现简单的机器学习算法 master_chenchengg python python 办公效率 python开发 IT
Python实现简单的机器学习算法开篇：初探机器学习的奇妙之旅搭建环境：一切从安装开始必备工具箱第一步：安装Anaconda和JupyterNotebook小贴士：如何配置Python环境变量算法初体验：从零开始的Python机器学习线性回归：让数据说话数据准备：从哪里找数据编码实战：Python实现线性回归模型评估：如何判断模型好坏逻辑回归：从分类开始理论入门：什么是逻辑回归代码实现：使用skl
推荐算法_隐语义-梯度下降 _feivirus_ 算法机器学习和数学推荐算法机器学习隐语义
importnumpyasnp1.模型实现"""inputrate_matrix:M行N列的评分矩阵，值为P*Q.P:初始化用户特征矩阵M*K.Q:初始化物品特征矩阵K*N.latent_feature_cnt:隐特征的向量个数max_iteration:最大迭代次数alpha:步长lamda:正则化系数output分解之后的P和Q"""defLFM_grad_desc(rate_matrix,l
K近邻算法_分类鸢尾花数据集 _feivirus_ 算法机器学习和数学分类机器学习 K近邻
importnumpyasnpimportpandasaspdfromsklearn.datasetsimportload_irisfromsklearn.model_selectionimporttrain_test_splitfromsklearn.metricsimportaccuracy_score1.数据预处理iris=load_iris()df=pd.DataFrame(data=ir
python中的深拷贝与浅拷贝 anshejd70787 python
深拷贝和浅拷贝浅拷贝的时候，修改原来的对象，浅拷贝的对象不会发生改变。1、对象的赋值对象的赋值实际上是对象之间的引用：当创建一个对象，然后将这个对象赋值给另外一个变量的时候，python并没有拷贝这个对象，而只是拷贝了这个对象的引用。当对对象做赋值或者是参数传递或者作为返回值的时候，总是传递原始对象的引用，而不是一个副本。如下所示：>>>aList=["kel","abc",123]>>>bLis
jQuery 键盘事件keydown ,keypress ,keyup介绍 107x js jquery keydown keypress keyup
本文章总结了下些关于jQuery 键盘事件keydown ,keypress ,keyup介绍，有需要了解的朋友可参考。一、首先需要知道的是： 1、keydown() keydown事件会在键盘按下时触发. 2、keyup() 代码如下复制代码 $('input').keyup(funciton(){
AngularJS中的Promise bijian1013 JavaScript AngularJS Promise
一.Promise Promise是一个接口，它用来处理的对象具有这样的特点：在未来某一时刻（主要是异步调用）会从服务端返回或者被填充属性。其核心是，promise是一个带有then()函数的对象。为了展示它的优点，下面来看一个例子，其中需要获取用户当前的配置文件： var cu
c++ 用数组实现栈类 CrazyMizzz 数据结构 C++
#include<iostream> #include<cassert> using namespace std; template<class T, int SIZE = 50> class Stack{ private: T list[SIZE];//数组存放栈的元素 int top;//栈顶位置 public: Stack(
java和c语言的雷同麦田的设计者 java 递归 scaner
软件启动时的初始化代码，加载用户信息2015年5月27号从头学java二 1、语言的三种基本结构：顺序、选择、循环。废话不多说，需要指出一下几点： a、return语句的功能除了作为函数返回值以外，还起到结束本函数的功能，return后的语句不会再继续执行。 b、for循环相比于whi
LINUX环境并发服务器的三种实现模型被触发 linux
服务器设计技术有很多，按使用的协议来分有TCP服务器和UDP服务器。按处理方式来分有循环服务器和并发服务器。 1 循环服务器与并发服务器模型在网络程序里面，一般来说都是许多客户对应一个服务器，为了处理客户的请求，对服务端的程序就提出了特殊的要求。目前最常用的服务器模型有： ·循环服务器：服务器在同一时刻只能响应一个客户端的请求 ·并发服务器：服
Oracle数据库查询指令肆无忌惮_ oracle数据库
20140920 单表查询 -- 查询************************************************************************************************************ -- 使用scott用户登录 -- 查看emp表 desc emp
ext右下角浮动窗口知了ing JavaScript ext
第一种 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/
浅谈REDIS数据库的键值设计矮蛋蛋 redis
http://www.cnblogs.com/aidandan/ 原文地址：http://www.hoterran.info/redis_kv_design 丰富的数据结构使得redis的设计非常的有趣。不像关系型数据库那样，DEV和DBA需要深度沟通，review每行sql语句，也不像memcached那样，不需要DBA的参与。redis的DBA需要熟悉数据结构，并能了解使用场景。
maven编译可执行jar包 alleni123 maven
http://stackoverflow.com/questions/574594/how-can-i-create-an-executable-jar-with-dependencies-using-maven <build> <plugins> <plugin> <artifactId>maven-asse
人力资源在现代企业中的作用百合不是茶 HR 企业管理
//人力资源在在企业中的作用人力资源为什么会存在，人力资源究竟是干什么的人力资源管理是对管理模式一次大的创新，人力资源兴起的原因有以下点：工业时代的国际化竞争，现代市场的风险管控等等。所以人力资源在现代经济竞争中的优势明显的存在，人力资源在集团类公司中存在着明显的优势(鸿海集团)，有一次笔者亲自去体验过红海集团的招聘，只知道人力资源是管理企业招聘的当时我被招聘上了，当时给我们培训的人
Linux自启动设置详解 bijian1013 linux
linux有自己一套完整的启动体系，抓住了linux启动的脉络，linux的启动过程将不再神秘。阅读之前建议先看一下附图。本文中假设inittab中设置的init tree为： /etc/rc.d/rc0.d /etc/rc.d/rc1.d /etc/rc.d/rc2.d /etc/rc.d/rc3.d /etc/rc.d/rc4.d /etc/rc.d/rc5.d /etc
Spring Aop Schema实现 bijian1013 java spring AOP
本例使用的是Spring2.5 1.Aop配置文件spring-aop.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmln
【Gson七】Gson预定义类型适配器 bit1129 gson
Gson提供了丰富的预定义类型适配器，在对象和JSON串之间进行序列化和反序列化时，指定对象和字符串之间的转换方式， DateTypeAdapter public final class DateTypeAdapter extends TypeAdapter<Date> { public static final TypeAdapterFacto
【Spark八十八】Spark Streaming累加器操作（updateStateByKey) bit1129 update
在实时计算的实际应用中，有时除了需要关心一个时间间隔内的数据，有时还可能会对整个实时计算的所有时间间隔内产生的相关数据进行统计。比如：对Nginx的access.log实时监控请求404时，有时除了需要统计某个时间间隔内出现的次数，有时还需要统计一整天出现了多少次404，也就是说404监控横跨多个时间间隔。 Spark Streaming的解决方案是累加器，工作原理是，定义
linux系统下通过shell脚本快速找到哪个进程在写文件 ronin47
一个文件正在被进程写我想查看这个进程文件一直在增大找不到谁在写使用lsof也没找到这个问题挺有普遍性的，解决方法应该很多，这里我给大家提个比较直观的方法。 linux下每个文件都会在某个块设备上存放，当然也都有相应的inode, 那么透过vfs.write我们就可以知道谁在不停的写入特定的设备上的inode。幸运的是systemtap的安装包里带了inodewatch.stp，位
java-两种方法求第一个最长的可重复子串 bylijinnan java 算法
import java.util.Arrays; import java.util.Collections; import java.util.List; public class MaxPrefix { public static void main(String[] args) { String str="abbdabcdabcx";
Netty源码学习-ServerBootstrap启动及事件处理过程 bylijinnan java netty
Netty是采用了Reactor模式的多线程版本，建议先看下面这篇文章了解一下Reactor模式： http://bylijinnan.iteye.com/blog/1992325 Netty的启动及事件处理的流程，基本上是按照上面这篇文章来走的文章里面提到的操作，每一步都能在Netty里面找到对应的代码其中Reactor里面的Acceptor就对应Netty的ServerBo
servelt filter listener 的生命周期 cngolon filter listener servelt 生命周期
1. servlet 当第一次请求一个servlet资源时，servlet容器创建这个servlet实例，并调用他的 init(ServletConfig config)做一些初始化的工作，然后调用它的service方法处理请求。当第二次请求这个servlet资源时，servlet容器就不在创建实例，而是直接调用它的service方法处理请求，也就是说
jmpopups获取input元素值 ctrain JavaScript
jmpopups 获取弹出层form表单首先，我有一个div，里面包含了一个表单，默认是隐藏的，使用jmpopups时，会弹出这个隐藏的div，其实jmpopups是将我们的代码生成一份拷贝。当我直接获取这个form表单中的文本框时，使用方法：$('#form input[name=test1]').val()；这样是获取不到的。我们必须到jmpopups生成的代码中去查找这个值，$(
vi查找替换命令详解 daizj linux 正则表达式替换查找 vim
一、查找查找命令 /pattern<Enter> ：向下查找pattern匹配字符串 ?pattern<Enter>：向上查找pattern匹配字符串使用了查找命令之后，使用如下两个键快速查找： n：按照同一方向继续查找 N：按照反方向查找字符串匹配 pattern是需要匹配的字符串，例如： 1: /abc<En
对网站中的js,css文件进行打包 dcj3sjt126com PHP 打包
一，为什么要用smarty进行打包 apache中也有给js,css这样的静态文件进行打包压缩的模块，但是本文所说的不是以这种方式进行的打包，而是和smarty结合的方式来把网站中的js,css文件进行打包。为什么要进行打包呢，主要目的是为了合理的管理自己的代码。现在有好多网站，你查看一下网站的源码的话，你会发现网站的头部有大量的JS文件和CSS文件，网站的尾部也有可能有大量的J
php Yii: 出现undefined offset 或者 undefined index解决方案 dcj3sjt126com undefined
在开发Yii 时，在程序中定义了如下方式： if($this->menuoption[2] === 'test')，那么在运行程序时会报：undefined offset:2，这样的错误主要是由于php.ini 里的错误等级太高了，在windows下错误等级
linux 文件格式（1） sed工具 eksliang linux linux sed工具 sed工具 linux sed详解
转载请出自出处： http://eksliang.iteye.com/blog/2106082 简介 sed 是一种在线编辑器，它一次处理一行内容。处理时，把当前处理的行存储在临时缓冲区中，称为“模式空间”（pattern space），接着用sed命令处理缓冲区中的内容，处理完成后，把缓冲区的内容送往屏幕。接着处理下一行，这样不断重复，直到文件末尾
Android应用程序获取系统权限 gqdy365 android
引用如何使Android应用程序获取系统权限第一个方法简单点，不过需要在Android系统源码的环境下用make来编译： 1. 在应用程序的AndroidManifest.xml中的manifest节点
HoverTree开发日志之验证码 hvt .net C#asp.net hovertree webform
HoverTree是一个ASP.NET的开源CMS，目前包含文章系统，图库和留言板功能。代码完全开放，文章内容页生成了静态的HTM页面，留言板提供留言审核功能，文章可以发布HTML源代码，图片上传同时生成高品质缩略图。推出之后得到许多网友的支持，再此表示感谢！留言板不断收到许多有益留言，但同时也有不少广告，因此决定在提交留言页面增加验证码功能。ASP.NET验证码在网上找，如果不是很多，就是特别多
JSON API：用 JSON 构建 API 的标准指南中文版 justjavac json
译文地址：https://github.com/justjavac/json-api-zh_CN 如果你和你的团队曾经争论过使用什么方式构建合理 JSON 响应格式，那么 JSON API 就是你的 anti-bikeshedding 武器。通过遵循共同的约定，可以提高开发效率，利用更普遍的工具，可以是你更加专注于开发重点：你的程序。基于 JSON API 的客户端还能够充分利用缓存，
数据结构随记_2 lx.asymmetric 数据结构笔记
第三章栈与队列一．简答题 1. 在一个循环队列中，队首指针指向队首元素的前一个位置。 2.在具有n个单元的循环队列中，队满时共有 n-1 个元素。 3. 向栈中压入元素的操作是先移动栈顶指针&n
Linux下的监控工具dstat 网络接口 linux
1) 工具说明dstat是一个用来替换 vmstat,iostat netstat,nfsstat和ifstat这些命令的工具, 是一个全能系统信息统计工具. 与sysstat相比, dstat拥有一个彩色的界面, 在手动观察性能状况时, 数据比较显眼容易观察; 而且dstat支持即时刷新, 譬如输入dstat 3, 即每三秒收集一次, 但最新的数据都会每秒刷新显示. 和sysstat相同的是,
C 语言初级入门--二维数组和指针 1140566087 二维数组 c/c++指针
/* 二维数组的定义和二维数组元素的引用二维数组的定义：当数组中的每个元素带有两个下标时，称这样的数组为二维数组； (逻辑上把数组看成一个具有行和列的表格或一个矩阵); 语法：类型名数组名[常量表达式1][常量表达式2] 二维数组的引用：引用二维数组元素时必须带有两个下标，引用形式如下：例如： int a[3][4]; 引用：
10点睛Spring4.1-Application Event wiselyman application
10.1 Application Event Spring使用Application Event给bean之间的消息通讯提供了手段应按照如下部分实现bean之间的消息通讯继承ApplicationEvent类实现自己的事件实现继承ApplicationListener接口实现监听事件使用ApplicationContext发布消息