dogo_L1L
dogo_L1L

numpy 模块

目录

0x00 简介
0x01 数据类型
0x02 np的创建函数

  1. np.array()
  2. zeros()
  3. ones()
  4. full()
  5. arange()
  6. linspace()
  7. np.random.random()
  8. np.random.normal()
  9. np.random.randint()
  10. eye()
  11. empty()

0x03 矩阵的属性
0x04 通用函数
0x05 操作函数

  1. 切片
  2. 重塑
  3. 拼接
  4. 分裂

0x06 整体操作函数
0x07 掩码
0x08 排序
0x09 索引
0x10 保存和导入
关于广播/矩阵的适应

0x00 简介

numpy 是 python 数据科学计算的核心，并且计算的速度，比python内部函数+循环来的更加快速。

0x01 数据类型（dtype）

bool_：布尔值
int8：字节（-128～127）
int16：整型（-32768～32767）
int32：整型（-2147483648～2147483647）
int64：整型（-263～263-1）
uint8：无符号整型（0～255）常用表示颜色
uint16：无符号整型（0～2^16-1）
uint32：
uint64：
float16：半精度浮点型（1bit符号，5bit指数，10bit尾数）
float32：单精度浮点型（1bit符号，8bit指数，23bit尾数）
float64：双精度浮点型（1bit符号，11bit指数，52bit尾数）

0x02 np的创建函数

导入库
import numpy as np

np.array()

介绍：自定义创建矩阵/向量
矩阵：含有多组括号[]
向量：只有一组括号[]

  1. 默认数据类型为向上转换(int转float)
In [2]: np.array([3.14,4,2,3])
Out[2]: array([3.14, 4.  , 2.  , 3.  ])
注：int类型的4转为float类型的4.
  1. 自定义参数
In [3]: np.array([3.14,4,2,3],dtype='int8')
Out[3]: array([3, 4, 2, 3], dtype=int8)
  1. 创建多维的函数
In [4]: np.array([range(i,i+3) for i in [0,3,6]],dtype='float32')
Out[4]: 
array([[0., 1., 2.],
       [3., 4., 5.],
       [6., 7., 8.]], dtype=float32)

zeros()

介绍：创建一个元书全是0的矩阵

  1. 创建向量(向量只有一对[]方括号)
In [18]: np.zeros(5,dtype='int8')
Out[18]: array([0, 0, 0, 0, 0], dtype=int8)
  1. 创建零矩阵
In [20]: np.zeros((1,5),dtype='int8')
Out[20]: array([[0, 0, 0, 0, 0]], dtype=int8)
In [21]: np.zeros((3,2),dtype='int8')
Out[21]: 
array([[0, 0],
       [0, 0],
       [0, 0]], dtype=int8)
  1. 创建多维矩阵
In [23]: np.zeros((2,2,2),dtype='int8')
Out[23]: 
array([[[0, 0],
        [0, 0]],

       [[0, 0],
        [0, 0]]], dtype=int8)

ones()

介绍：创建所有元素为1的矩阵
操作同 zeros()

full()

介绍：填充矩阵，由同一个元素进行填充

In [24]: np.full((3,5),'hello')
Out[24]: 
array([['hello', 'hello', 'hello', 'hello', 'hello'],
       ['hello', 'hello', 'hello', 'hello', 'hello'],
       ['hello', 'hello', 'hello', 'hello', 'hello']], dtype='

arange()

np.arange(start,stop,step)
介绍：作用同python自带的range函数
参数：
start：开始值（默认为0）
stop：结束值
step：步长（默认为1）

  1. 正常情况
In [25]: np.arange(0,20,2)
Out[25]: array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18])
  1. 缺省情况
In [26]: np.arange(10)
Out[26]: 
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9])

linspace()

np.linspace(start,stop,n)
介绍：在start和stop之间平均间隔取n个值
start：开始值
stop：结束值(包含)
n：n个量

In [29]: np.linspace(0,10,9)
Out[29]: array([ 0.  ,  1.25,  2.5 ,  3.75,  5.  ,  6.25,  7.5 ,  8.75, 10.  ])

np.random.random()

简介：[0,1)之间随机取值

In [30]: np.random.random((3,3))
Out[30]: 
array([[0.82228874, 0.1089113 , 0.1042419 ],
       [0.39540648, 0.78447082, 0.93905377],
       [0.81706086, 0.05729816, 0.83167481]])

np.random.normal()

np.random.normal(mean,cov,())
简介：已正态分布的方式随机取值，平均值为mean，方差为cov的()矩阵

In [34]: np.random.normal(0,1,(3,3))
Out[34]: 
array([[-0.88787112,  0.44841522,  1.07864026],
       [-2.09751237,  1.65672209,  1.29646719],
       [-0.82968315,  0.30015648, -1.47379788]])

np.random.randint()

np.random.randint(start,stop,())
简介：在start:stop的范围内随机取整值构成()矩阵

In [36]: np.random.randint(0,10,(5,5))
Out[36]: 
array([[4, 0, 4, 6, 5],
       [2, 5, 9, 5, 0],
       [6, 9, 1, 8, 8],
       [3, 2, 8, 8, 9],
       [5, 3, 0, 6, 7]])

eye()

简介：构建一个单位矩阵E(对角线全部为1，其他全部为0)

In [37]: np.eye(5)
Out[37]: 
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.]])

empty()

简介：用内存垃圾制作一个矩阵

In [39]: np.empty(3)
Out[39]: array([0.00000000e+000, 1.84882922e-316, 6.90270845e-310])

0x03 矩阵的属性

  1. 先创建一个3*4*5的矩阵
In [41]: a3=np.random.randint(0,10,(3,4,5))

In [42]: a3
Out[42]: 
array([[[4, 7, 3, 4, 5],
        [7, 5, 8, 1, 6],
        [6, 4, 4, 1, 0],
        [1, 9, 2, 9, 0]],

       [[3, 6, 3, 8, 4],
        [1, 8, 5, 6, 8],
        [8, 9, 1, 6, 9],
        [8, 0, 8, 8, 4]],

       [[8, 2, 3, 5, 7],
        [6, 6, 4, 2, 5],
        [4, 9, 3, 7, 6],
        [4, 2, 7, 3, 2]]])
  1. 观察属性
矩阵的维度
In [43]: a3.ndim
Out[43]: 3
矩阵的形状
In [44]: a3.shape
Out[44]: (3, 4, 5)
矩阵的元素个数(3*4*5)
In [45]: a3.size
Out[45]: 60
矩阵的元素属性
In [46]: a3.dtype
Out[46]: dtype('int64')
矩阵每个元素所占的空间（64/8）
In [47]: a3.itemsize
Out[47]: 8
矩阵的总体所占的空间
In [48]: a3.nbytes
Out[48]: 480

0x04 通用函数

假设:
A=[0 1 2 3 4]
B=[1 2 3 4 5]

In [3]: A=np.array([0,1,2,3,4])
In [5]: A
Out[5]: array([0, 1, 2, 3, 4])
In [4]: B=np.array([1,2,3,4,5])
In [6]: B
Out[6]: array([1, 2, 3, 4, 5])
  1. 加法（所有元素都进行相加）
所有元素都+5
In [7]: A+5
Out[7]: array([5, 6, 7, 8, 9])
同np.add(A,5)
In [10]: np.add(A,5)
Out[10]: array([5, 6, 7, 8, 9])
  1. 减法
所有元素都-5
In [8]: A-5
Out[8]: array([-5, -4, -3, -2, -1])
同np.sutractb()
In [13]: np.subtract(A,5)
Out[13]: array([-5, -4, -3, -2, -1])
  1. 乘法
所有元素都进行乘法
In [14]: A*5
Out[14]: array([ 0,  5, 10, 15, 20])
同np.multiply(A,5)
In [15]: np.multiply(A,5)
Out[15]: array([ 0,  5, 10, 15, 20])
  1. 除法
所有元素都进行除法
In [16]: A/5
Out[16]: array([0. , 0.2, 0.4, 0.6, 0.8])
同np.divide()
In [17]: np.divide(A,5)
Out[17]: array([0. , 0.2, 0.4, 0.6, 0.8])
  1. 向下取整除法
In [20]: B//5
Out[20]: array([0, 0, 0, 0, 1])
同np.floor_divide()
In [21]: np.floor_divide(B,5)
Out[21]: array([0, 0, 0, 0, 1])
  1. 幂次运算
In [23]: A**2
Out[23]: array([ 0,  1,  4,  9, 16])
同np.power()
In [22]: np.power(A,2)
Out[22]: array([ 0,  1,  4,  9, 16])
  1. 取模运算
In [24]: A%2
Out[24]: array([0, 1, 0, 1, 0])
同np.mod()
In [25]: np.mod(A,2)
Out[25]: array([0, 1, 0, 1, 0])
  1. 绝对值运算
In [26]: np.abs([1,-2,3,-4])
Out[26]: array([1, 2, 3, 4])
  1. 指数运算
    自然底数（e）
In [27]: np.exp(A)
Out[27]: array([ 1.        ,  2.71828183,  7.3890561 , 20.08553692, 54.59815003])
  1. 底数运算
    自然底数ln()
In [30]: np.log(B,10)
Out[30]: array([0.        , 0.69314718, 1.09861229, 1.38629436, 1.60943791])

10为底

In [33]: np.log10(B)
Out[33]: array([0.        , 0.30103   , 0.47712125, 0.60205999, 0.69897   ])

2为底

In [32]: np.log2(B)
Out[32]: array([0.        , 1.        , 1.5849625 , 2.        , 2.32192809])
  1. 遍历执行
    reduce()
    对加法进行累加
In [37]: np.add.reduce(A)
Out[37]: 10
  1. 对中间过程的数据进行显示
In [38]: np.add.accumulate(A)
Out[38]: array([ 0,  1,  3,  6, 10])

0x05 操作函数

假设A=np.arange(16)

In [43]: A=np.arange(16)

In [44]: A
Out[44]: array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15])
  1. 切片
    对A进行切片的结果是一个子表a，子表a是A的一部分，类似C语言中的指针。对a进行操作就会对A产生影响。
a是A的一个子表
In [45]: a=A[1:8]

In [46]: a
Out[46]: array([1, 2, 3, 4, 5, 6, 7])
对a进行修改，就会对A产生影响
In [47]: a[0]=100

In [48]: a
Out[48]: array([100,   2,   3,   4,   5,   6,   7])
A的第2个元素被修改了
In [49]: A
Out[49]: 
array([  0, 100,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,
        13,  14,  15])

如果我们想制作一个副本就用.copy()方法

In [51]: A
Out[51]: array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15])


In [53]: a=A[1:8].copy()
生产副本
In [54]: a
Out[54]: array([1, 2, 3, 4, 5, 6, 7])
修改a
In [55]: a[0]=100

In [56]: a
Out[56]: array([100,   2,   3,   4,   5,   6,   7])
对A不产生影响
In [57]: A
Out[57]: array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15])
  1. 重塑
    a.reshape(shape, order='C')
    将A的元素重新作为一个矩阵
    默认选项
In [59]: A.reshape((4,4))
Out[59]: 
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])

列优先

In [66]: A.reshape((4,4),order='F')
Out[66]: 
array([[ 0,  4,  8, 12],
       [ 1,  5,  9, 13],
       [ 2,  6, 10, 14],
       [ 3,  7, 11, 15]])
  1. 拼接
    连接两个可以连接的矩阵
    创建A和B
    默认选项
生成A（矩阵）
In [3]: A=np.arange(16).reshape((4,4))
生成B（矩阵）
In [21]: B=np.array([np.arange(4)])

In [5]: A
Out[5]: 
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])
B是一个矩阵
In [22]: B
Out[22]: array([[0, 1, 2, 3]])
按行的方式进行连接
In [18]: np.concatenate([A,B])
Out[18]: 
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15],
       [ 0,  1,  2,  3]])

按列的方式进行连接

In [29]: np.concatenate([A,B.T],axis=1)
Out[29]: 
array([[ 0,  1,  2,  3,  0],
       [ 4,  5,  6,  7,  1],
       [ 8,  9, 10, 11,  2],
       [12, 13, 14, 15,  3]])
  1. 分裂
生成A
In [37]: A=np.array([np.arange(100)]).reshape((10,10))

In [38]: A
Out[38]: 
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, 27, 28, 29],
       [30, 31, 32, 33, 34, 35, 36, 37, 38, 39],
       [40, 41, 42, 43, 44, 45, 46, 47, 48, 49],
       [50, 51, 52, 53, 54, 55, 56, 57, 58, 59],
       [60, 61, 62, 63, 64, 65, 66, 67, 68, 69],
       [70, 71, 72, 73, 74, 75, 76, 77, 78, 79],
       [80, 81, 82, 83, 84, 85, 86, 87, 88, 89],
       [90, 91, 92, 93, 94, 95, 96, 97, 98, 99]])
分裂向量
In [36]: np.split(np.arange(16),[3,5,8])
Out[36]: 
[array([0, 1, 2]),
 array([3, 4]),
 array([5, 6, 7]),
 array([ 8,  9, 10, 11, 12, 13, 14, 15])]
分裂行
np.vsplit(A,[3,5,8])
In [39]: np.vsplit(A,[3,5,8])
Out[39]: 
[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, 27, 28, 29]]),
 array([[30, 31, 32, 33, 34, 35, 36, 37, 38, 39],
        [40, 41, 42, 43, 44, 45, 46, 47, 48, 49]]),
 array([[50, 51, 52, 53, 54, 55, 56, 57, 58, 59],
        [60, 61, 62, 63, 64, 65, 66, 67, 68, 69],
        [70, 71, 72, 73, 74, 75, 76, 77, 78, 79]]),
 array([[80, 81, 82, 83, 84, 85, 86, 87, 88, 89],
        [90, 91, 92, 93, 94, 95, 96, 97, 98, 99]])]
分裂列
In [41]: np.hsplit(A,[3,5,8])
Out[41]: 
[array([[ 0,  1,  2],
        [10, 11, 12],
        [20, 21, 22],
        [30, 31, 32],
        [40, 41, 42],
        [50, 51, 52],
        [60, 61, 62],
        [70, 71, 72],
        [80, 81, 82],
        [90, 91, 92]]), array([[ 3,  4],
        [13, 14],
        [23, 24],
        [33, 34],
        [43, 44],
        [53, 54],
        [63, 64],
        [73, 74],
        [83, 84],
        [93, 94]]), array([[ 5,  6,  7],
        [15, 16, 17],
        [25, 26, 27],
        [35, 36, 37],
        [45, 46, 47],
        [55, 56, 57],
        [65, 66, 67],
        [75, 76, 77],
        [85, 86, 87],
        [95, 96, 97]]), array([[ 8,  9],
        [18, 19],
        [28, 29],
        [38, 39],
        [48, 49],
        [58, 59],
        [68, 69],
        [78, 79],
        [88, 89],
        [98, 99]])]

0x06 整体操作函数

  1. 求和
    np.sum()
A：
In [44]: A=np.arange(10)

In [45]: A
Out[45]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [54]: np.sum(A)
Out[54]: 45

对一个轴进行求和

In [68]: A=np.array([np.arange(100)]).reshape((10,10))

In [69]: A
Out[69]: 
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, 27, 28, 29],
       [30, 31, 32, 33, 34, 35, 36, 37, 38, 39],
       [40, 41, 42, 43, 44, 45, 46, 47, 48, 49],
       [50, 51, 52, 53, 54, 55, 56, 57, 58, 59],
       [60, 61, 62, 63, 64, 65, 66, 67, 68, 69],
       [70, 71, 72, 73, 74, 75, 76, 77, 78, 79],
       [80, 81, 82, 83, 84, 85, 86, 87, 88, 89],
       [90, 91, 92, 93, 94, 95, 96, 97, 98, 99]])
以列为基进行求和
In [70]: np.sum(A,axis=1)
Out[70]: array([ 45, 145, 245, 345, 445, 545, 645, 745, 845, 945])
  1. 积
    1.求积
    np.prod
In [71]: A=np.arange(10)

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

In [73]: np.prod(A)
Out[73]: 0

2.以轴求积

In [2]: np.prod(np.arange(100).reshape((10,10)),axis=1)
Out[2]: 
array([                  0,        335221286400,      72684900288000,
          2306992893004800,   29820834418636800,  227991539359584000,
       1233909752121446400, 5227941748053024000,    5769992716765184,
       1193853638847869952])
  1. 平均值
    np.mean()
In [5]: np.mean(np.arange(10))
Out[5]: 4.5
  1. 标准差
    np.std()
In [7]: np.std(np.arange(10))
Out[7]: 2.8722813232690143
  1. 方差
    np.var()
In [6]: np.var(np.arange(10))
Out[6]: 8.25
  1. 最小值
    np.min()
In [9]: np.min(np.arange(10))
Out[9]: 0
  1. 最大值
    np.max()
In [2]: A=np.array(np.arange(10))

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

In [4]: np.max(A)
Out[4]: 9
  1. 最小值下标
    np.argmin()
In [6]: A=np.array([1,9,2,5,7,8,3,4])

In [7]: A
Out[7]: array([1, 9, 2, 5, 7, 8, 3, 4])

In [8]: np.argmin(A)
Out[8]: 0
  1. 最大值下标
    np.argmax()
In [6]: A=np.array([1,9,2,5,7,8,3,4])

In [7]: A
Out[7]: array([1, 9, 2, 5, 7, 8, 3, 4])

In [9]: np.argmax(A)
Out[9]: 1
  1. 中位数
    np.median()
In [6]: A=np.array([1,9,2,5,7,8,3,4])

In [7]: A
Out[7]: array([1, 9, 2, 5, 7, 8, 3, 4])

In [10]: np.median(A)
Out[10]: 4.5
  1. 计算基于元素排序的统计值（百分比）
In [14]: A=np.arange(9)


In [16]: A
Out[16]: array([0, 1, 2, 3, 4, 5, 6, 7, 8])
说明：2在A中的排行为25%
In [15]: np.percentile(A,25)
Out[15]: 2.0

0x07 掩码

当对A中的元素进行比较，比如A>5

In [22]: A=np.arange(10)

In [23]: A
Out[23]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
返回的是一个 bool 值
In [24]: A>5
Out[24]: 
array([False, False, False, False, False, False,  True,  True,  True,
        True])
A>5 等同于np.greater(A,5)
In [26]: np.greater(A,5)
Out[26]: 
array([False, False, False, False, False, False,  True,  True,  True,
        True])
类型为bool
In [31]: (A>5).dtype
Out[31]: dtype('bool')

将得到的 bool 值作为参数（掩码）False 下标的内容不显示

In [25]: A[A>5]
Out[25]: array([6, 7, 8, 9])
或者 A[np.greater(A,5)]
In [27]: A[np.greater(A,5)]
Out[27]: array([6, 7, 8, 9])

同样的，可以判断

==        等同于        np.equal()
!=        等同于          np.not_equal()
<          等同于        np.less()
<=        等同于        np.less_equal()
>          等同于        np.greater()
==        等同于        np.greater_equal()

当然还可以使用与或非（and,or,not)

In [40]: (A>5)&(A<9)
Out[40]: 
array([False, False, False, False, False, False,  True,  True,  True,
       False])

但是如果你用来and的话

In [58]: (A>5)and(A<9)
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
 in ()
----> 1 (A>5)and(A<9)

ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()

就会报错
原因是这样的。
&表示的是一种运算（只有0和1，True和False）
1&1=1 1&0=0 1|1=11|0=1
但是&&表示一种并联关系

x>5 and x<9         等同于数学中的        54)and(x<9) for x in A]
Out[57]: [False, False, False, False, False, True, True, True, True, False]

其他与掩码相关的函数

  1. 计数函数
In [59]: np.count_nonzero(A>5)
Out[59]: 4
或者用加法来伪装
In [60]: np.sum(A>5)
Out[60]: 4
  1. 判断是否存在True选项
In [61]: np.any(A>5)
Out[61]: True
  1. 是否全部为True选项
In [62]: np.all(A>5)
Out[62]: False

0x08 索引

  1. 假设A为一个向量
In [77]: A=np.arange(0,16,2)

In [78]: A
Out[78]: array([ 0,  2,  4,  6,  8, 10, 12, 14])

以 A 为基础进行索引，并新建一个新的矩阵。
索引为

In [79]: index=np.array([[3,5],[4,1]])

In [81]: index
Out[81]: 
array([[3, 5],
       [4, 1]])

通过索引建立一个矩阵

In [82]: A[index]
Out[82]: 
array([[ 6, 10],
       [ 8,  2]])

发现得到的结果的样子的模仿索引（矩阵）的，而不是模仿原矩阵A（向量）。
当然也可以对高维进行类似操作。

  1. 二维的A
In [83]: A=np.array([np.arange(16)]).reshape(4,4)

In [84]: A
Out[84]: 
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])

下标要分为x，和y

In [88]: indx=np.array([[1,2],[2,3]])

In [89]: indy=np.array([[1,2],[2,3]])

In [91]: indx
Out[91]: 
array([[1, 2],
       [2, 3]])

In [92]: indy
Out[92]: 
array([[1, 2],
       [2, 3]])

返回的矩阵

In [94]: A[indx,indy]
Out[94]: 
array([[ 5, 10],
       [10, 15]])
  1. 掩码的实际情况
    制作A
In [100]: A=np.arange(4)

模拟掩码

In [104]: A[[False,True,False,True]]
Out[104]: array([1, 3])

制作掩码配合索引

In [106]: A[np.array([1,0,1,0],dtype=bool)]
Out[106]: array([0, 2])

0x09 排序

随机生成A

In [107]: A=np.random.randn(16)

In [108]: A
Out[108]: 
array([ 0.94530282, -0.141438  , -0.48407457, -0.12291314,  2.16394776,
       -0.29973733,  0.052026  ,  0.02803714, -0.55796317,  1.14545362,
       -0.2746067 , -0.55784318,  0.92600829,  1.64408684,  0.44322179,
       -0.31919027])

对 A 进行排序
np.sort()

In [109]: np.sort(A)
Out[109]: 
array([-0.55796317, -0.55784318, -0.48407457, -0.31919027, -0.29973733,
       -0.2746067 , -0.141438  , -0.12291314,  0.02803714,  0.052026  ,
        0.44322179,  0.92600829,  0.94530282,  1.14545362,  1.64408684,
        2.16394776])

对A的下标进行排序
np.argsort()

In [110]: np.argsort(A)
Out[110]: array([ 8, 11,  2, 15,  5, 10,  1,  3,  7,  6, 14, 12,  0,  9, 13,  4])

利用argsort产生的下标，进行排序

In [111]: A[np.argsort(A)]
Out[111]: 
array([-0.55796317, -0.55784318, -0.48407457, -0.31919027, -0.29973733,
       -0.2746067 , -0.141438  , -0.12291314,  0.02803714,  0.052026  ,
        0.44322179,  0.92600829,  0.94530282,  1.14545362,  1.64408684,
        2.16394776])

部分排序
np.partition(A,3)

前3个是排序的，虽然看上去大部分是排序的
In [113]: np.partition(A,3)
Out[113]: 
array([-0.55796317, -0.55784318, -0.48407457, -0.31919027, -0.29973733,
       -0.2746067 , -0.141438  , -0.12291314,  0.02803714,  1.14545362,
        0.052026  ,  2.16394776,  0.92600829,  1.64408684,  0.44322179,
        0.94530282])

对多维的支持

In [116]: np.partition(np.array([np.random.randn(16)]).reshape((4,4)),2,axis=1)
Out[116]: 
array([[-1.45500322, -0.713915  , -0.36444806,  0.76913556],
       [-1.21572197, -0.88310406, -0.87936904,  2.8281161 ],
       [-0.60106417, -0.53714934,  0.63414093,  1.77827773],
       [-1.56662739, -0.66677067,  1.00912384,  1.30192062]])

0x10 保存和导入

  1. 文件的导入（这个方法不是最佳的文件导入方案，后面的 pd 库有更加好的方案）
    x, y = np.loadtxt(file, delimiter=',', usecols=(0, 2), unpack=True,skiprows=True)
    参数：
    file：文件地址
    delimiter：分隔符
    usecols：使用的列
    unpack：True表示返回的不是矩阵而是列。Flase表示返回的是矩阵。
    skiprows：是否跳过头行
    文件的内容
"x","y"
1,2
3,4
5,6
7,8
9,10

导入文件

In [5]: x, y = np.loadtxt('/home/lee/Desktop/try.csv', delimiter=',', usecols=(0
   ...: ,1), unpack=True,skiprows=True)

In [6]: x
Out[6]: array([1., 3., 5., 7., 9.])

In [7]: y
Out[7]: array([ 2.,  4.,  6.,  8., 10.])
  1. 导出保存
    np.savetxt()
In [8]: A=np.random.randn(25).reshape((5,5))

In [9]: A
Out[9]: 
array([[ 0.51824487, -0.37472096,  1.25555816,  1.71001234,  0.45111468],
       [ 0.47749389, -1.50971983, -0.41145998, -0.02848777,  0.48562952],
       [-0.23624129, -0.15610786, -0.78545659,  0.42037099, -0.66968623],
       [ 0.19242133,  0.06266058, -0.08899911,  0.70829686,  0.00334643],
       [ 0.81126511, -0.16912052,  0.02496709, -1.21912629, -0.13012915]])
导出文件
In [11]: np.savetxt('A.csv',A,delimiter=',')

In [12]: ls
A.csv               Music/              Templates/
Desktop/            np                  Untitled1.ipynb
Documents/          octave-workspace    Untitled2.ipynb
Downloads/          out.avi             Untitled.ipynb
eclipse/            Pictures/           Videos/
eclipse-workspace/  Public/             wineQQ8.9_19990.tar.xz
examples.desktop    readme20170121.txt
geckodriver.log     seaborn-data/

文件的信息

5.182448656943908771e-01,-3.747209575039990859e-01,1.255558157410590514e+00,1.710012343614627062e+00,4.511146824482026307e-01
4.774938862073087598e-01,-1.509719830624739023e+00,-4.114599838018008771e-01,-2.848777188694322574e-02,4.856295168492132386e-01
-2.362412912000312337e-01,-1.561078611462562993e-01,-7.854565876685821735e-01,4.203709870211888022e-01,-6.696862321783216832e-01
1.924213325267559727e-01,6.266058086914759462e-02,-8.899910644144291838e-02,7.082968612937837749e-01,3.346432262475090586e-03
8.112651068338976312e-01,-1.691205155328200371e-01,2.496708527888203896e-02,-1.219126288883054299e+00,-1.301291545407270434e-01

关于广播/矩阵的适应

当矩阵进行加法
比如：
A+1
A+B（A为1行，B只有1列）

In [13]: A=np.array([np.arange(5)])
A只有1行
In [14]: A
Out[14]: array([[0, 1, 2, 3, 4]])

In [15]: B=A.T
B只有1列
In [16]: B
Out[16]: 
array([[0],
       [1],
       [2],
       [3],
       [4]])

进行加法

In [17]: A+1
Out[17]: array([[1, 2, 3, 4, 5]])
A+B似乎有点无法解释
In [18]: A+B
Out[18]: 
array([[0, 1, 2, 3, 4],
       [1, 2, 3, 4, 5],
       [2, 3, 4, 5, 6],
       [3, 4, 5, 6, 7],
       [4, 5, 6, 7, 8]])

本身并不能直接的相加，因为矩阵的运算是有条件的，比如shape要相同。
所以 A+B 的时候，A 和 B 都进行了扩展
A扩展为

array([[0, 1, 2, 3, 4]
       [0, 1, 2, 3, 4]
       [0, 1, 2, 3, 4]
       [0, 1, 2, 3, 4]
       [0, 1, 2, 3, 4]])

B扩展为

array([[0，0，0，0，0],
       [1,1,1,1,1],
       [2,2,2,2,2],
       [3,3,3,3,3],
       [4,4,4,4,4]])

同样A+1的时候，1也被扩展了。
扩展是有严格条件的：

  1. 如果两个矩阵的维度不同，那么小维度的矩阵的shape将在最左边补1。
  2. 如果两个数组的行站在任何一个维度都不匹配，那么数组的现状会沿着维度为1的维度扩展以匹配另外一个数组的形状
  3. 如果来那个个数组的形状在任何一个维度上都不匹配并且没有一个维度为1,那么就会报错。
  4. 重复上述这3条

你可能感兴趣的:(numpy 模块)

  • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
  • Python开发常用的三方模块如下： 换个网名有点难 python开发语言
    Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
  • 推荐算法_隐语义-梯度下降 _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 tif转png Python与遥感 python开发语言
    importosfromosgeoimportgdalimportnumpyasnpfromPILimportImage#提取432三波段fromspectralimport*#输入文件夹路径defget_img(dataset_img):width=dataset_img.RasterXSize#获取行列数height=dataset_img.RasterYSizebands=dataset_i
  • 06选课支付模块之基于消息队列发送支付通知消息 echo 云清 学成在线javarabbitmq消息队列支付通知学成在线
    消息队列发送支付通知消息需求分析订单服务作为通用服务，在订单支付成功后需要将支付结果异步通知给其他对接的微服务，微服务收到支付结果根据订单的类型去更新自己的业务数据技术方案使用消息队列进行异步通知需要保证消息的可靠性即生产端将消息成功通知到服务端：消息发送到交换机-->由交换机发送到队列-->消费者监听队列，收到消息进行处理，参考文章02-使用Docker安装RabbitMQ-CSDN博客生产者确
  • tiff批量转png 诺有缸的高飞鸟 opencv图像处理pythonopencv图像处理
    目录写在前面代码完写在前面1、本文内容tiff批量转png2、平台/环境opencv,python3、转载请注明出处：https://blog.csdn.net/qq_41102371/article/details/132975023代码importnumpyasnpimportcv2importosdeffindAllFile(base):file_list=[]forroot,ds,fsin
  • 遥感影像的切片处理 sand&wich 计算机视觉python图像处理
    在遥感影像分析中，经常需要将大尺寸的影像切分成小片段，以便于进行详细的分析和处理。这种方法特别适用于机器学习和图像处理任务，如对象检测、图像分类等。以下是如何使用Python和OpenCV库来实现这一过程，同时确保每个影像片段保留正确的地理信息。准备环境首先，确保安装了必要的Python库，包括numpy、opencv-python和xml.etree.ElementTree。这些库将用于图像处理
  • Vue( ElementUI入门、vue-cli安装) m0_l5z elementuivue.js
    一.ElementUI入门目录：1.ElementUI入门1.1ElementUI简介1.2Vue+ElementUI安装1.3开发示例2.搭建nodejs环境2.1nodejs介绍2.2npm是什么2.3nodejs环境搭建2.3.1下载2.3.2解压2.3.3配置环境变量2.3.4配置npm全局模块路径和cache默认安装位置2.3.5修改npm镜像提高下载速度2.3.6验证安装结果3.运行n
  • Spring MVC 全面指南：从入门到精通的详细解析 一杯梅子酱 技术栈学习springmvcjava
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
  • 【RabbitMQ 项目】服务端：数据管理模块之绑定管理 月夜星辉雪 rabbitmq分布式
    文章目录一.编写思路二.代码实践一.编写思路定义绑定信息类交换机名称队列名称绑定关键字：交换机的路由交换算法中会用到没有是否持久化的标志，因为绑定是否持久化取决于交换机和队列是否持久化，只有它们都持久化时绑定才需要持久化。绑定就好像一根绳子，两端连接着交换机和队列，当一方不存在，它就没有存在的必要了定义绑定持久化类构造函数：如果数据库文件不存在则创建，打开数据库，创建binding_table插入
  • 进销存小程序源码 PHP网络版ERP进销存管理系统 全开源可二开 摸鱼小号 php
    可直接源码搭建部署发布后使用：一、功能模块介绍该系统模板主要有进，销，存三个主要模板功能组成，下面将介绍各模块所对应的功能；进：需要将产品采购入库，自动生成采购明细台账同时关联财务生成付款账单；销：是指对客户的销售订单记录，汇总生成产品销售明细及回款计划；存：库存的日常盘点与统计，库存下限预警、出入库台账、库存位置等。1.进购管理采购订单：采购下单审批→由上级审批通过采购入库；采购入库：货品到货>
  • 更改npm镜像源为淘宝镜像 骆小骆 基于node.js
    npm常用指令后缀*最近复习了一下node.js整理了一下跟node.js相关的指令后缀*--save、-S参数意思是把模块的版本信息保存到dependencies（生产环境依赖）中，即你的package.json文件的dependencies字段中；–--save-dev、-D参数意思是把模块版本信息保存到devDependencies（开发环境依赖）中，即你的package.json文件的de
  • Python 课程10-单元测试 可愛小吉 Python教學python单元测试开发语言TDDunittest
    前言在现代软件开发中，单元测试已成为一种必不可少的实践。通过测试，我们可以确保每个功能模块在开发和修改过程中按预期工作，从而减少软件缺陷，提高代码质量。而测试驱动开发（TDD）则进一步将测试作为开发的核心部分，先编写测试，再编写代码，以测试为指导开发出更稳定、更可靠的代码。Python提供了强大的unittest模块，它是Python标准库的一部分，专门用于编写和执行单元测试。与其他测试框架相比，
  • RabbitMQ生产者重复机制与确认机制 java炒饭小能手 java-rabbitmqrabbitmqjava
    重复机制生产者发送消息时，出现了网络故障，导致与MQ的连接中断。为了解决这个问题，SpringAMQP提供的消息发送时的重试机制。即：当RabbitTemplate与MQ连接超时后，多次重试。需要修该发送端模块的application.yaml文件，添加下面的内容：spring:rabbitmq:connection-timeout:1s#设置MQ的连接超时时间template:retry:ena
  • 使用由 Python 编写的 lxml 实现高性能 XML 解析 hunyxv python笔记pythonxml
    转载自：文章lxml简介Python从来不出现XML库短缺的情况。从2.0版本开始，它就附带了xml.dom.minidom和相关的pulldom以及SimpleAPIforXML(SAX)模块。从2.4开始，它附带了流行的ElementTreeAPI。此外，很多第三方库可以提供更高级别的或更具有python风格的接口。尽管任何XML库都足够处理简单的DocumentObjectModel(DOM
  • 【Python】已解决：ModuleNotFoundError: No module named ‘PIL’ 屿小夏 python开发语言
    文章目录一、分析问题背景二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：ModuleNotFoundError:Nomodulenamed‘PIL’一、分析问题背景当你在Python环境中尝试导入PIL（PythonImagingLibrary）模块时，可能会遇到“ModuleNotFoundError:Nomodulenamed‘PIL’”的错误。这通常发生在尝试使用PIL
  • RK3229_Android9.0_Box 4G模块EC200A调试 suifen_ 网络
    0、kernel修改这部分完全可以参考Linux的移植：RK3588EC200A-CN【4G模块】调试_rkec200a-cn-CSDN博客1、修改device/rockchip/rk322xdiff--gita/device.mkb/device.mkindexec6bfaa..e7c32d1100755---a/device.mk+++b/device.mk@@-105,6+105,8@@en
  • VUE3 + xterm + nestjs实现web远程终端 或 连接开启SSH登录的路由器和交换机。 焚木灵 node.jsvue
    可远程连接系统终端或开启SSH登录的路由器和交换机。相关资料：xtermjs/xterm.js:Aterminalfortheweb(github.com)后端实现(NestJS)：1、安装依赖：npminstallnode-ssh@nestjs/websockets@nestjs/platform-socket.io2、我们将创建一个名为RemoteControlModule的NestJS模块，
  • metaRTC8.0，一个全新架构的webRTC SDK库 metaRTC webrtc音视频
    概述metaRTC8.0是metaRTC开源以来架构变化最大的一个版本，是metaIPC3.0等高性能的基础。metaRTC8.0是一个全新架构版本，并非在metaRTC7.0版本上简单升级，在QOS/语音对讲/内存占用/视频文件录制读取等方面新增多个模块，在弱网对抗/语音对讲/内存优化等效果上有显著提升。metaRTC8.0在一年多的开发中进行了近200次迭代，metaRTC8.0社区版计划在2
  • 【新教育-教师随笔】读《做最好的英语老师》有感 164c5aca7b79
    伊川县直中学王素平《做最好的英语老师》这本书是作者这些年在他教学中得与失的总结。里面给我们提供了听力，单词，句子，阅读，作文等模块的教学方法，让我受益匪浅，现总结如下：一.语文教学给了我们什么启示？（1）：现有的英语教材内容简单，枯燥，与学生的心智发展水平严重脱节。我们要给学生补中一些贴近学生生活，能感动和影响他们的经典作品。让学生学习知识的同时，有所感悟和思考，同时享受审美的乐趣！如AWiseO
  • ansible的安装、使用 ytym00
    简介高度模块化，调用特定的模块，完成特定的任务，基于Yaml，来完成批量任务的模板化，来支持playbook。基于Python语言实现，主要使用Paramiko、PyYAML和JinJa2三个关键模块，部署简单(agentless)，主从模式，支持自定义模块，支持playbook，幂等性：允许重复执行N次，没有变化时，只会执行第一次。特点：1、Configuration(cfengine,chef
  • KVM虚拟机源代码分析【转】 xidianjiapei001 #虚拟化技术
    1.KVM结构及工作原理1.1KVM结构KVM基本结构有两部分组成。一个是KVMDriver，已经成为Linux内核的一个模块。负责虚拟机的创建，虚拟内存的分配，虚拟CPU寄存器的读写以及虚拟CPU的运行等。另外一个是稍微修改过的Qemu，用于模拟PC硬件的用户空间组件，提供I/O设备模型以及访问外设的途径。KVM基本结构如图1所示。其中KVM加入到标准的Linux内核中，被组织成Linux中标准
  • Nginx之代理模块 ngx_http_proxy_module 途径日暮不赏丶 nginxnginx
    正向代理正向代理是指位于客户机（A）和站点服务器（B）之间的代理服务器（C），为了从站点服务器（B）获取资源，客户机（A）向代理服务器（C）发送请求并指定站点服务器（B），然后代理服务器（C）向站点服务器（B）转交请求并将获取的资源返回给客户机（A）。上述这样的代理模式称为正向代理，正向代理最大的特点：客户端非常明确要访问的服务器地址；服务器只清楚请求来自哪个代理服务器，而不清楚来自哪个具体的客户
  • Nginx之ngx_http_proxy_connect_module模块 小米bb Nginxnginxhttp运维
    近期由于项目需要使用到https正向代理，而nginx官方模块仅支持做http正向代理，一番百度学习后发现了该模块，故今日记录下此笔记供大家一起学习交流ngx_http_proxy_connect_module模块主要用于隧道SSL请求的代理服务器GitHub地址：http://www.github.com/chobits/ngx_http_proxy_connect_modulenginx配置：
  • Hadoop 傲雪凌霜，松柏长青 后端大数据hadoop大数据分布式
    ApacheHadoop是一个开源的分布式计算框架，主要用于处理海量数据集。它具有高度的可扩展性、容错性和高效的分布式存储与计算能力。Hadoop核心由四个主要模块组成，分别是HDFS（分布式文件系统）、MapReduce（分布式计算框架）、YARN（资源管理）和HadoopCommon（公共工具和库）。1.HDFS（HadoopDistributedFileSystem）HDFS是Hadoop生
  • python中zeros用法_Python中的numpy.zeros()用法 江平舟 python中zeros用法
    numpy.zeros()函数是最重要的函数之一,广泛用于机器学习程序中。此函数用于生成包含零的数组。numpy.zeros()函数提供给定形状和类型的新数组,并用零填充。句法numpy.zeros(shape,dtype=float,order='C'参数形状：整数或整数元组此参数用于定义数组的尺寸。此参数用于我们要在其中创建数组的形状,例如(3,2)或2。dtype：数据类型(可选)此参数用于
  • 【NumPy】深入解析numpy.zeros()函数 二七830 numpy
    欢迎莅临我的个人主页这里是我深耕Python编程、机器学习和自然语言处理（NLP）领域，并乐于分享知识与经验的小天地！博主简介：我是二七830，一名对技术充满热情的探索者。多年的Python编程和机器学习实践，使我深入理解了这些技术的核心原理，并能够在实际项目中灵活应用。尤其是在NLP领域，我积累了丰富的经验，能够处理各种复杂的自然语言任务。技术专长：我熟练掌握Python编程语言，并深入研究了机
  • 2. 变量和指令（omron 机器自动化控制器）——2 一半不眠次日si记 OMRONNJ/NX系列PLC指令基准手册自动化运维
    机器自动化控制器——第二章变量和指令22-2指令一览通用指令轴指令轴组指令2-3PDO映射必需对象▶伺服轴▶编码器轴不同指令的设定对象▶伺服轴▶编码器轴2-2指令一览运动控制指令分为以下3种。种类概要通用指令MC功能模块通用指令轴指令MC功能模块执行单轴控制的指令轴组指令MC功能模块执行多轴协调控制的指令通用指令的详情参阅“第5章通用指令”，轴指令的详情参阅“第3章轴指令”，轴组的详情参阅“第4章
  • 2. 变量和指令（omron 机器自动化控制器）——1 一半不眠次日si记 OMRONNJ/NX系列PLC指令基准手册自动化运维
    机器自动化控制器——第二章变量和指令12-1变量一览表MC通用变量轴变量▶轴组变量运动控制指令的输入变量输入变量的有效范围▶枚举体一览表运动控制指令的输出变量运动控制指令的输入输出变量2-1变量一览表MC功能模块使用的变量分为两类。一类是监视轴等的状态及部分参数设定内容的系统定义变量。MC功能模块使用的系统定义变量被称作运动控制系统变量。还有一类是运动控制指令将指令的自变量作为输入接收、将指令的执
  • 集合框架 天子之骄 java数据结构集合框架
       集合框架 集合框架可以理解为一个容器，该容器主要指映射(map)、集合(set)、数组(array)和列表(list)等抽象数据结构。 从本质上来说，Java集合框架的主要组成是用来操作对象的接口。不同接口描述不同的数据类型。   简单介绍：   Collection接口是最基本的接口，它定义了List和Set，List又定义了LinkLi
  • Table Driven（表驱动）方法实例 bijian1013 javaenumTable Driven表驱动
    实例一： /** * 驾驶人年龄段 * 保险行业，会对驾驶人的年龄做年龄段的区分判断 * 驾驶人年龄段：01-[18,25);02-[25,30);03-[30-35);04-[35,40);05-[40,45);06-[45,50);07-[50-55);08-[55,+∞) */ public class AgePeriodTest { //if...el
  • Jquery 总结 cuishikuan javajqueryAjaxWebjquery方法
    1.$.trim方法用于移除字符串头部和尾部多余的空格。如：$.trim('   Hello   ') // Hello2.$.contains方法返回一个布尔值，表示某个DOM元素（第二个参数）是否为另一个DOM元素（第一个参数）的下级元素。如：$.contains(document.documentElement, document.body); 3.$
  • 面向对象概念的提出 麦田的设计者 java面向对象面向过程
            面向对象中，一切都是由对象展开的，组织代码，封装数据。   在台湾面向对象被翻译为了面向物件编程，这充分说明了，这种编程强调实体。       下面就结合编程语言的发展史，聊一聊面向过程和面向对象。      c语言由贝尔实
  • linux网口绑定 被触发 linux
    刚在一台IBM Xserver服务器上装了RedHat Linux Enterprise AS 4，为了提高网络的可靠性配置双网卡绑定。 一、环境描述 我的RedHat Linux Enterprise AS 4安装双口的Intel千兆网卡，通过ifconfig -a命令看到eth0和eth1两张网卡。 二、双网卡绑定步骤： 2.1 修改/etc/sysconfig/network
  • XML基础语法 肆无忌惮_ xml
    一、什么是XML？ XML全称是Extensible Markup Language，可扩展标记语言。很类似HTML。XML的目的是传输数据而非显示数据。XML的标签没有被预定义，你需要自行定义标签。XML被设计为具有自我描述性。是W3C的推荐标准。   二、为什么学习XML？ 用来解决程序间数据传输的格式问题 做配置文件 充当小型数据库   三、XML与HTM
  • 为网页添加自己喜欢的字体 知了ing 字体 秒表 css
    @font-face { font-family: miaobiao;//定义字体名字 font-style: normal; font-weight: 400; src: url('font/DS-DIGI-e.eot');//字体文件 } 使用： <label style="font-size:18px;font-famil
  • redis范围查询应用-查找IP所在城市 矮蛋蛋 redis
    原文地址： http://www.tuicool.com/articles/BrURbqV 需求 根据IP找到对应的城市 原来的解决方案 oracle表（ip_country）： 查询IP对应的城市： 1.把a.b.c.d这样格式的IP转为一个数字，例如为把210.21.224.34转为3524648994 2. select city from ip_
  • 输入两个整数， 计算百分比 alleni123 java
    public static String getPercent(int x, int total){ double result=(x*1.0)/(total*1.0); System.out.println(result); DecimalFormat df1=new DecimalFormat("0.0000%");
  • 百合——————>怎么学习计算机语言 百合不是茶 java 移动开发
        对于一个从没有接触过计算机语言的人来说，一上来就学面向对象，就算是心里上面接受的了，灵魂我觉得也应该是跟不上的，学不好是很正常的现象，计算机语言老师讲的再多，你在课堂上面跟着老师听的再多，我觉得你应该还是学不会的，最主要的原因是你根本没有想过该怎么来学习计算机编程语言，记得大一的时候金山网络公司在湖大招聘我们学校一个才来大学几天的被金山网络录取，一个刚到大学的就能够去和
  • linux下tomcat开机自启动 bijian1013 tomcat
    方法一： 修改Tomcat/bin/startup.sh 为: export JAVA_HOME=/home/java1.6.0_27 export CLASSPATH=$CLASSPATH:$JAVA_HOME/lib/tools.jar:$JAVA_HOME/lib/dt.jar:. export PATH=$JAVA_HOME/bin:$PATH export CATALINA_H
  • spring aop实例 bijian1013 javaspringAOP
    1.AdviceMethods.java package com.bijian.study.spring.aop.schema; public class AdviceMethods { public void preGreeting() { System.out.println("--how are you!--"); } } 2.beans.x
  • [Gson八]GsonBuilder序列化和反序列化选项enableComplexMapKeySerialization bit1129 serialization
    enableComplexMapKeySerialization配置项的含义  Gson在序列化Map时，默认情况下，是调用Key的toString方法得到它的JSON字符串的Key，对于简单类型和字符串类型，这没有问题，但是对于复杂数据对象，如果对象没有覆写toString方法，那么默认的toString方法将得到这个对象的Hash地址。   GsonBuilder用于
  • 【Spark九十一】Spark Streaming整合Kafka一些值得关注的问题 bit1129 Stream
    包括Spark Streaming在内的实时计算数据可靠性指的是三种级别： 1. At most once，数据最多只能接受一次，有可能接收不到 2. At least once, 数据至少接受一次，有可能重复接收 3. Exactly once  数据保证被处理并且只被处理一次，   具体的多读几遍http://spark.apache.org/docs/lates
  • shell脚本批量检测端口是否被占用脚本 ronin47
    #!/bin/bash cat ports |while read line do#nc -z -w 10 $line nc -z -w 2 $line 58422>/dev/null2>&1if[ $?-eq 0]then echo $line:ok else echo $line:fail fi done 这里的ports 既可以是文件
  • java-2.设计包含min函数的栈 bylijinnan java
    具体思路参见：http://zhedahht.blog.163.com/blog/static/25411174200712895228171/ import java.util.ArrayList; import java.util.List; public class MinStack { //maybe we can use origin array rathe
  • Netty源码学习-ChannelHandler bylijinnan javanetty
    一般来说，“有状态”的ChannelHandler不应该是“共享”的，“无状态”的ChannelHandler则可“共享” 例如ObjectEncoder是“共享”的, 但 ObjectDecoder 不是 因为每一次调用decode方法时，可能数据未接收完全（incomplete）， 它与上一次decode时接收到的数据“累计”起来才有可能是完整的数据，是“有状态”的 p
  • java生成随机数 cngolon java
    方法一： /** * 生成随机数 * @author [email protected] * @return */ public synchronized static String getChargeSequenceNum(String pre){ StringBuffer sequenceNum = new StringBuffer(); Date dateTime = new D
  • POI读写海量数据 ctrain 海量数据
    import java.io.FileOutputStream; import java.io.OutputStream; import org.apache.poi.xssf.streaming.SXSSFRow; import org.apache.poi.xssf.streaming.SXSSFSheet; import org.apache.poi.xssf.streaming
  • mysql 日期格式化date_format详细使用 daizj mysqldate_format日期格式转换日期格式化
    日期转换函数的详细使用说明  DATE_FORMAT(date,format) Formats the date value according to the format string. The following specifiers may be used in the format string. The&n
  • 一个程序员分享8年的开发经验 dcj3sjt126com 程序员
      在中国有很多人都认为IT行为是吃青春饭的，如果过了30岁就很难有机会再发展下去!其实现实并不是这样子的，在下从事.NET及JAVA方面的开发的也有8年的时间了，在这里在下想凭借自己的亲身经历，与大家一起探讨一下。 明确入行的目的 很多人干IT这一行都冲着“收入高”这一点的，因为只要学会一点HTML, DIV+CSS，要做一个页面开发人员并不是一件难事，而且做一个页面开发人员更容
  • android欢迎界面淡入淡出效果 dcj3sjt126com android
    很多Android应用一开始都会有一个欢迎界面，淡入淡出效果也是用得非常多的，下面来实现一下。 主要代码如下： package com.myaibang.activity; import android.app.Activity;import android.content.Intent;import android.os.Bundle;import android.os.CountDown
  • linux 复习笔记之常见压缩命令 eksliang tar解压linux系统常见压缩命令linux压缩命令tar压缩
    转载请出自出处:http://eksliang.iteye.com/blog/2109693 linux中常见压缩文件的拓展名 *.gz gzip程序压缩的文件 *.bz2 bzip程序压缩的文件 *.tar tar程序打包的数据，没有经过压缩 *.tar.gz tar程序打包后，并经过gzip程序压缩 *.tar.bz2 tar程序打包后，并经过bzip程序压缩 *.zi
  • Android 应用程序发送shell命令 gqdy365 android
    项目中需要直接在APP中通过发送shell指令来控制lcd灯，其实按理说应该是方案公司在调好lcd灯驱动之后直接通过service送接口上来给APP，APP调用就可以控制了，这是正规流程，但我们项目的方案商用的mtk方案，方案公司又没人会改，只调好了驱动，让应用程序自己实现灯的控制，这不蛋疼嘛！！！！ 发就发吧！ 一、关于shell指令： 我们知道，shell指令是Linux里面带的
  • java 无损读取文本文件 hw1287789687 读取文件无损读取读取文本文件charset
    java 如何无损读取文本文件呢？ 以下是有损的 @Deprecated public static String getFullContent(File file, String charset) { BufferedReader reader = null; if (!file.exists()) { System.out.println("getFull
  • Firebase 相关文章索引 justjavac firebase
    Awesome Firebase 最近谷歌收购Firebase的新闻又将Firebase拉入了人们的视野，于是我做了这个 github 项目。 Firebase 是一个数据同步的云服务，不同于 Dropbox 的「文件」，Firebase 同步的是「数据」，服务对象是网站开发者，帮助他们开发具有「实时」（Real-Time）特性的应用。 开发者只需引用一个 API 库文件就可以使用标准 RE
  • C++学习重点 lx.asymmetric C++笔记
    1.c++面向对象的三个特性：封装性，继承性以及多态性。   2.标识符的命名规则：由字母和下划线开头，同时由字母、数字或下划线组成；不能与系统关键字重名。   3.c++语言常量包括整型常量、浮点型常量、布尔常量、字符型常量和字符串性常量。   4.运算符按其功能开以分为六类：算术运算符、位运算符、关系运算符、逻辑运算符、赋值运算符和条件运算符。 &n
  • java bean和xml相互转换 q821424508 javabeanxmlxml和bean转换java bean和xml转换
    这几天在做微信公众号 做的过程中想找个java bean转xml的工具，找了几个用着不知道是配置不好还是怎么回事，都会有一些问题， 然后脑子一热谢了一个javabean和xml的转换的工具里，自己用着还行，虽然有一些约束吧 ， 还是贴出来记录一下      顺便你提一下下，这个转换工具支持属性为集合、数组和非基本属性的对象。   packag
  • C 语言初级 位运算 1140566087 位运算c
    第十章 位运算   1、位运算对象只能是整形或字符型数据，在VC6.0中int型数据占4个字节   2、位运算符： 运算符 作用 ~ 按位求反 << 左移 >> 右移 & 按位与 ^ 按位异或 | 按位或 他们的优先级从高到低；   3、位运算符的运算功能： a、按位取反： ~01001101 = 101
  • 14点睛Spring4.1-脚本编程 wiselyman spring4
    14.1 Scripting脚本编程 脚本语言和java这类静态的语言的主要区别是:脚本语言无需编译,源码直接可运行; 如果我们经常需要修改的某些代码,每一次我们至少要进行编译,打包,重新部署的操作,步骤相当麻烦; 如果我们的应用不允许重启,这在现实的情况中也是很常见的; 在spring中使用脚本编程给上述的应用场景提供了解决方案,即动态加载bean; spring支持脚本
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他