一. python简介

1. python 具有丰富强大的库，常被称为胶水语言，能够把用其他语言制作的各种模块很轻松地联结在一起

2. python强制使用空白符（white space）作为语句缩进。

3. 可以使用 py2exe等包转换成系统能够执行的文件。

4. Python的瓶颈不在于自身语言的运行时间，在于一些网络速度等外在因素的影响。

二. Python库

1. python版本

常用的有2.7和3.5两个版本，这两个版本不完全兼容。但就目前Windows的环境而言，Python2.7对于数据分析领域就足够用了，但3.5更多用于web开发。当然，也可以使用 2to3.py 实现两个版本之间的转换。

  1. D:\>python 2to3.py t1.py
  2. RefactoringTool: Skipping optional fixer: buffer
  3. RefactoringTool: Skipping optional fixer: idioms
  4. RefactoringTool: Skipping optional fixer: set_literal
  5. RefactoringTool: Skipping optional fixer: ws_comma
  6. RefactoringTool: Refactored t1.py
  7. --- t1.py       (original)
  8. +++ t1.py       (refactored)
  9. @@ -1 +1 @@
  10. -print 'all tasks has been finished!'
  11. +print('all tasks has been finished!')
  12. RefactoringTool: Files that need to be modified:
  13. RefactoringTool: t1.py

不推荐大家使用上面这个转换的库，因为官网上说这个库会随着时间发生剧烈的变化。

2. pip

pip是安装python包的推荐工具：https://pypi.python.org/pypi/pip

也可以手动更换pip中的数据源：pip install -l https://pypi.tuna.tsinghua.edu.cn/simple numpy

pip会在数据源中查找符合你系统配置的最新版的安装包进行自动安装。

3. numpy

为Python提供快速的多维数组处理能力

4. pandas

在numpy基础上提供了更多了数据读写工具

5. scipy

在numpy基础上添加了众多科学计算工具包

6.matplotlib

Python丰富的绘图库，主要针对二维绘图，有少数的三维绘图函数

三. 数据生成

1. list, array

标准Python的列表list中，元素本质是对象

如：L=[1,2,3],需要3个指针和三个整数对象，对于数值运算比较浪费内存和CPU。

因此，numpy提供了ndarray(N-dimensional array object)对象:存储单一数据类型的多维数组。

  1. # # 1.使用array创建
  2. # 通过array函数传递list对象
  3. L = [1, 2, 3, 4, 5, 6]
  4. print "L = ", L
  5. a = np.array(L)

　print "a = ", a
  print type(a), type(L)
  # # 若传递的是多层嵌套的list，将创建多维数组
  b = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
  print b

2. 改变数组的大小和形状

  1.     # # # # # 数组大小可以通过其shape属性获得
  2.     print a.shape
  3.     print b.shape
  4.     #
  5.     # # # 也可以强制修改shape
  6.     b.shape = 4, 3
  7.     print b
  8.     # # 注：从(3,4)改为(4,3)并不是对数组进行转置，而只是改变每个轴的大小，数组元素在内存中的位置并没有改变
  9.     #
  10.     # # # 当某个轴为-1时，将根据数组元素的个数自动计算此轴的长度
  11.     b.shape = 2, -1
  12.     print b
  13.     print b.shape
  14.     #
  15.     b.shape = 3, 4
  16.     print b
  17.     # # # # 使用reshape方法，可以创建改变了尺寸的新数组，原数组的shape保持不变
  18.     c = b.reshape((4, -1))
  19.     print "b = \n", b
  20.     print 'c = \n', c

3. 数组的存储，类型

  1.     # # # # 数组b和c共享内存，修改任意一个将影响另外一个
  2.     b[0][1] = 20
  3.     print "b = \n", b
  4.     print "c = \n", c
  5.     #
  6.     # # # # 数组的元素类型可以通过dtype属性获得
  7.     print a.dtype
  8.     print b.dtype
  9.     # # # # #
  10.     # # # # # 可以通过dtype参数在创建时指定元素类型
  11.     d = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]], dtype=np.float)
  12.     f = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]], dtype=np.complex)
  13.     print d
  14.     print f
  15.     #
  16.     # # # 如果更改元素类型，可以使用astype安全的转换
  17.     f = d.astype(np.int)
  18.     print f
  19.     # # #
  20.     # # # # 但不要强制仅修改元素类型，如下面这句，将会以int来解释单精度float类型
  21.     d.dtype = np.int
  22.     print d下面是上面代码中倒数第二个d, 和f的输出
  1. [[  1.   2.   3.   4.]
  2.  [  5.   6.   7.   8.]
  3.  [  9.  10.  11.  12.]]
  4. [[  1.+0.j   2.+0.j   3.+0.j   4.+0.j]
  5.  [  5.+0.j   6.+0.j   7.+0.j   8.+0.j]
  6.  [  9.+0.j  10.+0.j  11.+0.j  12.+0.j]]
  8. 4. 使用函数创建
  1. # 如果生成一定规则的数据，可以使用NumPy提供的专门函数
  2. # arange函数类似于python的range函数：指定起始值、终止值和步长来创建数组
  3. # 和Python的range类似，arange同样不包括终值；但arange可以生成浮点类型，而range只能是整数类型
  4. np.set_printoptions(linewidth=100, suppress=True)
  5. a = np.arange(1, 10, 0.5)
  6. print a
  7.  
  8. # # # # linspace函数通过指定起始值、终止值和元素个数来创建数组，缺省包括终止值
  9. b = np.linspace(1, 10, 10)
  10. print 'b = ', b
  11.  
  12. # # 可以通过endpoint关键字指定是否包括终值
  13. c = np.linspace(1, 10, 10, endpoint=False)
  14. print 'c = ', c
  15.  
  16. # # # 和linspace类似，logspace可以创建等比数列
  17. # # 下面函数创建起始值为10^1，终止值为10^2，有10个数的等比数列
  18. d = np.logspace(1, 4, 4, endpoint=True, base=2)
  19. print d
  20. # # # # #
  21. # # # # # 下面创建起始值为2^0，终止值为2^10(包括)，有10个数的等比数列
  22. f = np.logspace(0, 10, 11, endpoint=True, base=2)
  23. print f
  24. #
  25. # # # # 使用 frombuffer, fromstring, fromfile等函数可以从字节序列创建数组
  26. s = 'abcdzzzz'
  27. g = np.fromstring(s, dtype=np.int8)
  28. print g
  29. # #

下面为输出结果：

  1. [ 1.   1.5  2.   2.5  3.   3.5  4.   4.5  5.   5.5  6.   6.5  7.   7.5  8.   8.5  9.   9.5]
  2. b =  [  1.   2.   3.   4.   5.   6.   7.   8.   9.  10.]
  3. c =  [ 1.   1.9  2.8  3.7  4.6  5.5  6.4  7.3  8.2  9.1]
  4. [  2.   4.   8.  16.]
  5. [    1.     2.     4.     8.    16.    32.    64.   128.   256.   512.  1024.]
  6. [ 97  98  99 100 122 122 122 122]
  7.  
  8. 5. 存取
    1）常规办法
  1.     # 数组元素的存取方法和Python的标准方法相同
  2.     a = np.arange(10)
  3.     print a
  4.     # # # 获取某个元素
  5.     print a[3]
  6.     # # # # # 切片[3,6)，左闭右开
  7.     print a[3:6]
  8.     # # # 省略开始下标，表示从0开始
  9.     print a[:5]
  10.     # # # 下标为负表示从后向前数
  11.     print a[3:]
  12.     # # 步长为2
  13.     print a[1:9:2]
  14.     # # # # # # 步长为-1，即翻转
  15.     print a[::-1]
  16.     # # 切片数据是原数组的一个视图，与原数组共享内容空间，可以直接修改元素值
  17.     a[1:4] = 10, 20, 30
  18.     print a
  19.     # # 因此，在实践中，切实注意原始数据是否被破坏，如：
  20.     b = a[2:5]
  21.     b[0] = 200
  22.     print a
  1. [0 1 2 3 4 5 6 7 8 9]
  2. 3
  3. [3 4 5]
  4. [0 1 2 3 4]
  5. [3 4 5 6 7 8 9]
  6. [1 3 5 7]
  7. [9 8 7 6 5 4 3 2 1 0]
  8. [ 0 10 20 30  4  5  6  7  8  9]
  9. [  0  10 200  30   4   5   6   7   8   9]
  10.  
  11. 2）整数/布尔数组存取
  1.     # 3.2.1
  2.     # 根据整数数组存取：当使用整数序列对数组元素进行存取时，
  3.     # 将使用整数序列中的每个元素作为下标，整数序列可以是列表(list)或者数组(ndarray)。
  4.     # 使用整数序列作为下标获得的数组不和原始数组共享数据空间。
  5.     a = np.logspace(0, 9, 10, base=2)
  6.     print a
  7.     i = np.arange(0, 10, 2)
  8.     print i
  9.     # # # 利用i取a中的元素
  10.     b = a[i]
  11.     print b
  12.     # # # b的元素更改，a中元素不受影响
  13.     b[2] = 1.6
  14.     print b
  15.     print a
  16.  
  17.     # # 3.2.2
  18.     # 使用布尔数组i作为下标存取数组a中的元素：返回数组a中所有在数组b中对应下标为True的元素
  19.     # 生成10个满足[0,1)中均匀分布的随机数
  20.     a = np.random.rand(10)
  21.     print a
  22.     # # 大于0.5的元素索引
  23.     print a > 0.5
  24.     # # # 大于0.5的元素
  25.     b = a[a > 0.5]
  26.     print b
  27.     # # # 将原数组中大于0.5的元素截取成0.5
  28.     a[a > 0.5] = 0.5
  29.     print a
  30.     # # # # # b不受影响
  31.     print b
  1. [   1.    2.    4.    8.   16.   32.   64.  128.  256.  512.]
  2. [0 2 4 6 8]
  3. [   1.    4.   16.   64.  256.]
  4. [   1.     4.     1.6   64.   256. ]
  5. [   1.    2.    4.    8.   16.   32.   64.  128.  256.  512.]
  6. [ 0.6863079   0.43770902  0.06801346  0.75436358  0.94302857  0.79214232  0.08905118  0.50204237
  7.   0.20263459  0.67341405]
  8. [ True False False  True  True  True False  True False  True]
  9. [ 0.6863079   0.75436358  0.94302857  0.79214232  0.50204237  0.67341405]
  10. [ 0.5         0.43770902  0.06801346  0.5         0.5         0.5         0.08905118  0.5
  11.   0.20263459  0.5       ]
  12. [ 0.6863079   0.75436358  0.94302857  0.79214232  0.50204237  0.67341405]
  13.  
  14. 3)切片
  1.     # 3.3 二维数组的切片
  2.     # [[ 0  1  2  3  4  5]
  3.     #  [10 11 12 13 14 15]
  4.     #  [20 21 22 23 24 25]
  5.     #  [30 31 32 33 34 35]
  6.     #  [40 41 42 43 44 45]
  7.     #  [50 51 52 53 54 55]]
  8.     a = np.arange(0, 60, 10)    # 行向量
  9.     print 'a = ', a
  10.     b = a.reshape((-1, 1))      # 转换成列向量
  11.     print b
  12.     c = np.arange(6)
  13.     print c
  14.     f = b + c   # 行 + 列
  15.     print f
  16.     # # 合并上述代码：
  17.     a = np.arange(0, 60, 10).reshape((-1, 1)) + np.arange(6)
  18.     print a
  19.     # # # 二维数组的切片
  20.     print '++++++++++++++'
  21.     print a[[0, 1, 2], [2, 3, 4]]
  22.     print a[4, [2, 3, 4]]
  23.     print a[4:, [2, 3, 4]]
  24.     print '+++++++++++++'
  25.     i = np.array([True, False, True, False, False, True])
  26.     print i
  27.     print a[i]
  28.     print a[i, 3]
  1. a =  [ 0 10 20 30 40 50]
  2. [[ 0]
  3.  [10]
  4.  [20]
  5.  [30]
  6.  [40]
  7.  [50]]
  8. [0 1 2 3 4 5]
  9. [[ 0  1  2  3  4  5]
  10.  [10 11 12 13 14 15]
  11.  [20 21 22 23 24 25]
  12.  [30 31 32 33 34 35]
  13.  [40 41 42 43 44 45]
  14.  [50 51 52 53 54 55]]
  15. [[ 0  1  2  3  4  5]
  16.  [10 11 12 13 14 15]
  17.  [20 21 22 23 24 25]
  18.  [30 31 32 33 34 35]
  19.  [40 41 42 43 44 45]
  20.  [50 51 52 53 54 55]]
  21. ++++++++++++++
  22. [ 2 13 24]
  23. [42 43 44]
  24. [[42 43 44]
  25.  [52 53 54]]
  26. +++++++++++++
  27. [ True False  True False False  True]
  28. [[ 0  1  2  3  4  5]
  29.  [20 21 22 23 24 25]
  30.  [50 51 52 53 54 55]]
  31. [ 3 23 53]
  32.  
  33. 上面代码中，
  1.  a[i]中索引 i 因为是布尔数组，所以它实际上是对对应行的选择，TRUE为选择，FALSE为不选择。
  1. 6.numpy与Python数学库的时间比较
  1.     for j in np.logspace(0, 7, 8):
  2.          x = np.linspace(0, 10, j)
  3.          start = time.clock()
  4.          y = np.sin(x)
  5.          t1 = time.clock() - start
  6.  
  7.          x = x.tolist()
  8.          start = time.clock()
  9.          for i, t in enumerate(x):
  10.              x[i] = math.sin(t)
  11.          t2 = time.clock() - start
  12.          print j, ": ", t1, t2, t2/t1
  1. 1.0 :  8.00000000001e-06 9.00000000015e-06 1.12500000002
  2. 10.0 :  0.000125 0.000319 2.552
  3. 100.0 :  1.20000000001e-05 0.000231 19.2499999998
  4. 1000.0 :  0.000138 0.000307 2.22463768116
  5. 10000.0 :  0.000383 0.002946 7.69190600522
  6. 100000.0 :  0.003997 0.029284 7.32649487115
  7. 1000000.0 :  0.038909 0.326851 8.40039579532
  8. 10000000.0 :  0.390234 2.951487 7.5633773582
    从上面的运行结果可以看出来，一般情况下，numpy的效率比Python数学库要快，平均快7倍左右
  9.  
  10. 7. 元素去重
  1.     # 4.2 元素去重
  2.     # 4.2.1直接使用库函数
  3.     a = np.array((1, 2, 3, 4, 5, 5, 7, 3, 2, 2, 8, 8))
  4.     print '原始数组：', a
  5.     # # # 使用库函数unique
  6.     b = np.unique(a)
  7.     print '去重后：', b
  8.     # # 4.2.2 二维数组的去重，结果会是预期的么？
  9.     c = np.array(((1, 2), (3, 4), (5, 6), (1, 3), (3, 4), (7, 6)))
  10.     print '二维数组：\n', c
  11.     print '去重后：', np.unique(c)
  12.     # # # 4.2.3 方案1：转换为虚数
  13.     r, i = np.split(c, (1, ), axis=1)
  14.     x = r + i * 1j
  15.     x = c[:, 0] + c[:, 1] * 1j
  16.     print '转换成虚数：', x
  17.     print '虚数去重后：', np.unique(x)
  18.     print np.unique(x, return_index=True)   # 思考return_index的意义
  19.     idx = np.unique(x, return_index=True)[1]
  20.     print '二维数组去重：\n', c[idx]
  21.     # # 4.2.3 方案2：利用set
  22.     print '去重方案2：\n', np.array(list(set([tuple(t) for t in c])))原始数组： [1 2 3 4 5 5 7 3 2 2 8 8]
  1. 去重后： [1 2 3 4 5 7 8]
  2. 二维数组：
  3. [[1 2]
  4.  [3 4]
  5.  [5 6]
  6.  [1 3]
  7.  [3 4]
  8.  [7 6]]
  9. 去重后： [1 2 3 4 5 6 7]
  10. 转换成虚数： [ 1.+2.j  3.+4.j  5.+6.j  1.+3.j  3.+4.j  7.+6.j]
  11. 虚数去重后： [ 1.+2.j  1.+3.j  3.+4.j  5.+6.j  7.+6.j]
  12. (array([ 1.+2.j,  1.+3.j,  3.+4.j,  5.+6.j,  7.+6.j]), array([0, 3, 1, 2, 5]))
  13. 二维数组去重：
  14. [[1 2]
  15.  [1 3]
  16.  [3 4]
  17.  [5 6]
  18.  [7 6]]
  19. 去重方案2：
  20. [[1 2]
  21.  [5 6]
  22.  [7 6]
  23.  [1 3]
  24.  [3 4]]
    从上面输出结果可以看出：
    a. 直接使用np.unique(c)为二维数组去重，不能达到理想的结果。因为unique会默认将输入的数组拉成一维的，然后去重。
    b. 对于二维数组去重，一般会选择先将其转成虚数去重，然后再还原成二维。但该种方式会打乱数组里面元素的顺序，所以我们可以令参数return_index=true来让其放回各个元素原始的索引。
    c. 使用set来去重需要先将数组转成list然后再进行操作。
  26. 8.三维数组去重
  1.     # 4.3 stack and axis
  2.     a = np.arange(1, 7).reshape((2, 3))
  3.     b = np.arange(11, 17).reshape((2, 3))
  4.     c = np.arange(21, 27).reshape((2, 3))
  5.     d = np.arange(31, 37).reshape((2, 3))
  6.     print 'a = \n', a
  7.     print 'b = \n', b
  8.     print 'c = \n', c
  9.     print 'd = \n', d
  10.     s = np.stack((a, b, c, d), axis=0)
  11.     print 'axis = 0 ', s.shape, '\n', s
  12.     s = np.stack((a, b, c, d), axis=1)
  13.     print 'axis = 1 ', s.shape, '\n', s
  14.     s = np.stack((a, b, c, d), axis=2)
  15.     print 'axis = 2 ', s.shape, '\n', s
  16.  
  17.     a = np.arange(1, 10).reshape(3,3)
  18.     print a
  19.     b = a + 10
  20.     print b
  21.     print np.dot(a, b)    ###矩阵乘法
  22.     print a * b           ##矩阵元素相乘
  23.  
  24.     a = np.arange(1, 10)
  25.     print a
  26.     b = np.arange(20,25)
  27.     print b
  28.     print np.concatenate((a, b))   ###连接
  1. a =
  2. [[1 2 3]
  3.  [4 5 6]]
  4. b =
  5. [[11 12 13]
  6.  [14 15 16]]
  7. c =
  8. [[21 22 23]
  9.  [24 25 26]]
  10. d =
  11. [[31 32 33]
  12.  [34 35 36]]
  13. axis = 0  (4, 2, 3)
  14. [[[ 1  2  3]
  15.   [ 4  5  6]]
  16.  
  17.  [[11 12 13]
  18.   [14 15 16]]
  19.  
  20.  [[21 22 23]
  21.   [24 25 26]]
  22.  
  23.  [[31 32 33]
  24.   [34 35 36]]]
  25. axis = 1  (2, 4, 3)
  26. [[[ 1  2  3]
  27.   [11 12 13]
  28.   [21 22 23]
  29.   [31 32 33]]
  30.  
  31.  [[ 4  5  6]
  32.   [14 15 16]
  33.   [24 25 26]
  34.   [34 35 36]]]
  35. axis = 2  (2, 3, 4)
  36. [[[ 1 11 21 31]
  37.   [ 2 12 22 32]
  38.   [ 3 13 23 33]]
  39.  
  40.  [[ 4 14 24 34]
  41.   [ 5 15 25 35]
  42.   [ 6 16 26 36]]]
  43. [[1 2 3]
  44.  [4 5 6]
  45.  [7 8 9]]
  46. [[11 12 13]
  47.  [14 15 16]
  48.  [17 18 19]]
  49. [[ 90  96 102]
  50.  [216 231 246]
  51.  [342 366 390]]
  52. [[ 11  24  39]
  53.  [ 56  75  96]
  54.  [119 144 171]]
  55. [1 2 3 4 5 6 7 8 9]
  56. [20 21 22 23 24]
  57. [ 1  2  3  4  5  6  7  8  9 20 21 22 23 24]
  58.  
  59. 函数stack实现多个数组堆叠的功能。从运行结果可以看出，当
  1. axis=0时， 是将a, b, c, d四个数组分别作为元素组成新的列向量中的元素；
  1. axis=1时，是分别将a, b, c, d四个数组中的第一个元素组成一个新的列元素，第二个元素也是同样的，最后组成一个列向量。
  1. axis=2时，是将a,b,c,d四个数组先拉成一维，然后分别取四个数组中相同位置的元素组成新的列向量中的元素。

机器学习---笔记----Python基础的更多相关文章

  1. Python学习笔记—Python基础1 介绍、发展史、安装、基本语法

    第一周学习笔记: 一.Python介绍      1.Python的创始人为吉多·范罗苏姆.1989年的圣诞节期间,吉多·范罗苏姆为了在阿姆斯特丹打发时间,决心开发一个新的脚本解释程序,作为ABC语言 ...

  2. 笔记-Python基础教程（第二版）第一章

    第一章 快速改造:基础知识 01:整除.乘方 (Python3.0之前 如2.7版本) >>> 1/2 ==>0 1/2整除,普通除法: 解决办法1: 1.0/2.0  ==& ...

  3. [笔记] Python基础---列表

    1.定义列表 列表由数据构成的有限序列,即按照一定的线性顺序排列,排列而成的数据项的集合. 2.创建列表 使用‘[ ]’括起来就已经创建了一个列表,例: my_first_list = [] #空列表 ...

  4. 学习笔记-python基础

    一. 1.python按装 1.1 官网 https://www.python.org 1.2 点 downloads下的 windows下载64位python3.7.3版本 Download Win ...

  5. Python基础_文件的的处理及异常处理

    今天主要讲讲文件读写及异常处理. 一.文件操作 1.1 文件的创建及读 打开文件 open 函数  open(file,[option]) file 是要打开的文件 option是可选择的参数文件的打 ...

  6. Python机器学习笔记：sklearn库的学习

    网上有很多关于sklearn的学习教程,大部分都是简单的讲清楚某一方面,其实最好的教程就是官方文档. 官方文档地址:https://scikit-learn.org/stable/ (可是官方文档非常 ...

  7. Python机器学习笔记：不得不了解的机器学习面试知识点（1）

    机器学习岗位的面试中通常会对一些常见的机器学习算法和思想进行提问,在平时的学习过程中可能对算法的理论,注意点,区别会有一定的认识,但是这些知识可能不系统,在回答的时候未必能在短时间内答出自己的认识,因 ...

  8. Python机器学习笔记：不得不了解的机器学习知识点（2）

    之前一篇笔记: Python机器学习笔记:不得不了解的机器学习知识点(1) 1,什么样的资料集不适合用深度学习? 数据集太小,数据样本不足时,深度学习相对其它机器学习算法,没有明显优势. 数据集没有局 ...

  9. Python机器学习笔记 集成学习总结

    集成学习(Ensemble  learning)是使用一系列学习器进行学习,并使用某种规则把各个学习结果进行整合,从而获得比单个学习器显著优越的泛化性能.它不是一种单独的机器学习算法啊,而更像是一种优 ...

随机推荐

  1. highchart柱状堆叠图动态数据请求

    $(function () { var options = { chart: { renderTo: 'indoor', type: 'column', }, title: { text: '室内问题 ...

  2. HDU - 1400 Mondriaan's Dream

    HDU - 1400 思路: 轮廓线dp入门题 #include<bits/stdc++.h> using namespace std; #define fi first #define ...

  3. css sticker footer

    .detail position: fixed z-index: 100 top: 0 left: 0 width: 100% height: 100% overflow: auto .detail- ...

  4. 第 4 章 容器 - 028 - 限制容器对CPU的使用

    限制容器对CPU的使用 默认设置下,所有容器可以平等地使用 host CPU 资源并且没有限制. Docker 可以通过 -c 或 --cpu-shares 设置容器使用 CPU 的权重.如果不指定, ...

  5. C# http监听之Nancy.net

    通过winform或者是控制台应用程序监听http请求,之前使用的是微软的HttpListener,参考https://www.cnblogs.com/duanjt/p/5566336.html 然后 ...

  6. Bulk RNA-Seq转录组学习

    与之对应的是single cell RNA-Seq,后面也会有类似文章. 参考:https://github.com/xuzhougeng/Learn-Bioinformatics/ 作业:RNA-s ...

  7. English Voice of <<Dream it passible>>

    Dream It Possible(梦想成为可能) - DelaceyI will run I will climb I will soar.我奔跑,我攀爬 我要飞翔.I'm undefeated我所 ...

  8. 记一次RAID阵列的迁移经历

    xu言: 最近,某电信机房因为空调漏水问题导致了我司的Dell R430 服务器的主板及CPU不同程度受损.服务器已经不能正常开机.但是,又基于把服务器的数据需要最短时间进行恢复.抱着试试看的心里进行 ...

  9. linux基础3

    vim编辑器 vim 操作命令 在命令模式下操作 pageup 往上翻页(重要指数****) pagedown 往下翻页(重要指数****) H 移动到屏幕首行 gg 移动光标到文档的首行(重要指数* ...

  10. AS（Android Studio）不停的updating indices

    有同事问我他as进入后updating iindices个不停 就在此处一直刷一直刷,虽然对他项目没什么影响,但总归很是烦人,解决办法如下: 打开File->Invalidate Caches ...