↑↑↑点击上方“蓝字”，关注“极客猴”
如果你喜欢极客猴，可以把我置顶或加为星标
题图：by watercolor.illustrations from Instagram
阅读文本大概需要 3 分钟。
List (列表)是 Python 中最基本的数据结构。在用法上，它有点类似数组，因为每个列表都有一个下标，下标从 0 开始。因此，我们可以使用 list[1] 来获取下标对应的值。如果我们深入下列表的底层原理，会发现列表是基于 PyListObject 实现的。PyListObject 是一个变长对象，所以列表的长度是随着元素多少动态改变的。同时它还支持插入和删除等操作，所以它还是一个可变对象。
可以简单理解为，Python 的列表是长度可变的数组。一般而已，我们用于列表创建都是一维数组。那么问题来，我们如果创建多维数组呢？
01 列表能创建多维数组？
列表是支持操作符，如果一个列表与 ‘ * ’ 号结合使用，能达到重复列表的效果。比如
list_one = [0]
list_two = [0] * 3
print(list_one)
print(list_two)
>>> 运行结果：
[0]
[0, 0, 0]
那么利用这个重复特性，我们是否可以来创建一个二维数组呢？于是乎，我进行一顿猛操作，结果就被我折腾出来了。
list_one = [0]
list_two = [[0] * 3] * 3
print(list_one)
print(list_two)

>>> 运行结果：

[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
看起来很完美的操作，但是如果进行一些列表更新操作，问题就显露出来了。比如我对 list_two 的更换中间位置的值，即对 list_two[1][1] 进行更换值。
list_two = [[0] * 3] * 3
print(list_two)

list_two[1][1] = 2
print(list_two)
不难发现，运行结果有点不对劲，列表中有三个位置的值也改变了。
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 2, 0], [0, 2, 0], [0, 2, 0]]
为什么会出现在这种情况呢？原因是浅拷贝，我们以这种方式创建的列表，list_two 里面的三个列表的内存是指向同一块，不管我们修改哪个列表，其他两个列表也会跟着改变。
如果要使用列表创建一个二维数组，可以使用生成器来辅助实现。
list_three = [[0 for i in range(3)] for j in range(3)]
print(list_three)
list_three[1][1] = 3
print(list_three)
我们对 list_three 进行更新操作，这次就能正常更新了。
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 3, 0], [0, 0, 0]]
除了以上的方式，还有一种更加简洁方便的方式，就是使用 NumPy 模块。
02 相比 List，NumPy 数组的优势
NumPy 全称为 Numerical Python，是 Python 的一个以矩阵为主的用于科学计算的基础软件包。NumPy 和 Pandas、Matpotlib 经常结合一起使用，所以被人们合称为数据分析三剑客。
Numpy 中有功能强大的 ndarray 对象，能创建 N 维的数组，另外还提供很多通用函数，支持对数组的元素进行操作、支持对数组进行算法运算以及提供常用的统计函数。
相比 List 对象，NumPy 数组有以下优势：
1.这是因为列表 list 的元素在系统内存中是分散存储的，而 NumPy 数组存储在一个均匀连续的内存块中。这样数组计算遍历所有元素，不像列表 list 还需要对内存地址进行查找，从而节省了计算资源。
2.Numpy数组能够运用向量化运算来处理整个数组，速度较快；而 Python 的列表则通常需要借助循环语句遍历列表，运行效率相对来说要差。
3.NumPy 中的矩阵计算可以采用多线程的方式，充分利用多核 CPU 计算资源，大大提升了计算效率。
4.Numpy 使用了优化过的 C API，运算速度较快。
03 创建数组
前面说到 NumPy 的主要对面是 ndarray 对象，它其实是一系列同类型数据的集合。因为 ndarray 支持创建多维数组，所以就有两个行和列的概念。
创建 ndarray 的第一种方式是利用 array 方式。
import numpy as np
# 创建一维数组
nd_one = np.array([1, 2, 3])
# 创建二维数组
nd_two = np.array([[1, 2, 3], [4, 5, 6]])

print(nd_one)
print(nd_two)
print('nd_two.shape =', nd_one.shape)
print('nd_two.shape =', nd_two.shape)

>>> 运行结果：

[1 2 3]
[[1 2 3]
 [4 5 6]]
nd_two.shape = (3,)
nd_two.shape = (2, 3)
其中 shape 是数组的一个属性，表示获取数组大小(有多少行，有多少列)，如果是一维数组，则只显示(行，)。代码中打印出 nd_two 的形状，输出为(2，3)，表示数组中有 2 行 3 列。
第二种办法则使用 Numpy 的内置函数
1.使用arange 或 linspace 创建连续数组。
import numpy as np
# arange() 类似Python内置函数的 range()
# arange(初始值, 终值, 步长) 不包含终值
x0 = np.arange(1, 11, 2)
print(x0)

# 创建一个 5x3 的数组
x1 = np.arange(15).reshape((5, 3))
print(x1)

# linspace()线性等分向量
# linspace(初始值, 终值, 元素个数) 包含终值
x2 = np.linspace(1, 11, 6)
print(x2)

>>> 运行结果：

[1 3 5 7 9]

[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]
 [12 13 14]]

[  1.   3.   5.   7.   9.  11.]
虽然 np.arange 和 np.linspace 起到的作用是一样的，都是创建等差数组，但是创建的方式是不同的。
2.使用 zeros()，ones()，full() 创建数组
import numpy as np
# 创建一个 3x4 的数组且所有值全为 0
x3 = np.zeros((3, 4), dtype=int)
print(x3)
# 创建一个 3x4 的数组且所有元素值全为 1
x4 = np.ones((3, 4), dtype=int)
print(x4)
# 创建一个 3x4 的数组，然后将所有元素的值填充为 2
x5 = np.full((3, 4), 2, dtype=int)
print(x5)

>>> 运行结果：

[[0 0 0 0]
 [0 0 0 0]
 [0 0 0 0]]

[[1 1 1 1]
 [1 1 1 1]
 [1 1 1 1]]

[[2 2 2 2]
 [2 2 2 2]
 [2 2 2 2]]
 3.使用 eye() 创建单位矩阵
import numpy as np
# 创建 3x3 的单位矩阵
x6 = np.eye(3, dtype=int)
print(x6)

>>> 运行结果：

[[1 0 0]
 [0 1 0]
 [0 0 1]]
4.使用 diag() 创建对角矩阵
diag() 是创建一个 NxN 的对角矩阵，对角矩阵是对角线上的主对角线之外的元素皆为 0 的矩阵。
import numpy as np
x7 = np.diag([1, 2, 3])
print(x7)

>>> 运行结果：

[[1 0 0]
 [0 2 0]
 [0 0 3]]
5.使用 random 创建随机数组
numpy 中的 random 中有很多内置函数，能简单介绍其中的几种。
import numpy as np
# 创建 2x2 数组且所有值是随机填充
x9 = np.random.random((2, 2))
print(x9)

# 创建一个值在 [0, 10) 区间的 3x3 的随机整数
x10 = np.random.randint(0, 10, (3, 3))
print(x10)

>>> 运行结果：

[[ 0.77233522  0.41516417]
 [ 0.22350126  0.31611254]]

[[0 6 5]
 [7 6 4]
 [5 5 9]]
—END—
精彩推荐如何使用Python玩转PDF各种骚操作？500行代码，教你用python写个微信飞机大战计算机学生如何规划好大学四年的学习？

	

固定长度的数组

固定长度类型数组的声明及其通过length方法获取数组长度求和。

pragma solidity ^0.4.4;
/*
数组一旦创建，长度不可变
但里面的内容可变
*/
contract Sz {

  //定义长为5的数组，并对其初始化。
  uint[5] T = [1,2,3,4,5];

  //计算数组中所有数的和。
  function numbers() constant returns (uint) {
    uint count = 0;
    for(uint i=0;i<T.length;i++){
      count = count + T[i];
      // count += T[i]; //同上
    }
    return count;
  }
}


声明数组时，一旦长度固定，将不能再修改数组的长度，可以修改其内容。

可变长度的数组

声明方式

pragma solidity ^0.4.4;

contract Sz {

  //定义可变数组，并对其初始化。
  uint[] T = [1,2,3,4,5];

  //因为上步中初始化5个元素，所有默认长度为5
  function Tlength() constant returns (uint) {
    return T.length;
  }
}


修改长度

function setLength(uint len) {
    T.length = len;
  }

修改值的两种方法

//修改值
  function setIndexValue() {
    T[0] =5;
  }
  function pushValue() {
    T.push(10);
  }

另外的一种创建方式

uint[] T1 = new uint[](5);//5是初始长度，默认值为[0,0,0,0,0]
  //进行赋值
  function Sz() {
    for(uint i=0;i<5;i++){
      //  T1.push(i);  //push后长度会发生变化
      T1[i] = i+1;
    }  
  }

二维数组

定义方法1

pragma solidity ^0.4.4;

contract Sz {

  //定义长为3的二维数组，并对其初始化。
  uint[2][3] T = [[1,2],[3,4],[5,6]];

  //计算数组中所有数的和。
  function Sz_length() constant returns (uint) {
    return T.length; //3
  }
}


注意：与一般二维数组（行列）相反。

定义方法2

uint[2][] T1= new uint[2][](0);

修改值

// 修改值
  function pushToT1(uint[2] t) {
    T1.push(t);
  }
  // 查看修改后的长度变化
  function T1length() constant returns (uint) {
    return T1.length;
  }

memory类型数组

创建方式

pragma solidity ^0.4.4;

contract Sz {

  function f(uint len) {

    uint[] memory a = new uint[](7);
    bytes memory b = new bytes(len);

    a[6] = 4;
    b[1] = 0x68;
  }
}

注意：创建一个长度为length的memory类型的数组可以通过new关键字来创建，memory数组一旦创建，它不可通过length修改其长度，但可以改变其内容。（若不加memory关键字，默认的是storage类型）

类型转换问题

pragma solidity ^0.4.4;

contract Sz {

  function f() {
  //  g([1,2,3]);  //直接调用会报错，因为g函数中默认的是uint256，而此处默认的是uint8，因此需要强转
    g([uint(1),2,3]);
  }

  function g(uint[3] data) {
    //....
  }
}


memory类型的固定长度数组不可直接赋值给storage/memory类型的可变数组



总结：

bytes1~32创建的是固定字节大小的字节数组，长度不可变，内容不可修改。而string是特殊的可变字节数组，它可以转换为bytes以通过length你方法获取它的字节长度，亦可通过索引修改相对于的字节内容。

创建可变字节数组除了可以通过bytes b = new bytes(len)来创建之外，还可以通过byte[] b来创建。

而bytes1~32我们可以通过byte[len] b 来创建，len的范围为1~32。不过这 两种方式创建的不可变字节数组有一点小区别：bytes1~32直接声明的不可变字节数组中，长度不可变，内容不可变。而byte[len] b创建的字节数组，长度不可变，但内容可修改。

二维数组
    /*
      二维数组
      数组中的每一个元素又是一个数组
      声明
         int[][] a;
     */
    public static void main(String[] args) {
          /*
           new int[3][3]
            创建一个二维数组,二维数组的长度为3,二维数组中的一维数组长度也是3

             {{0,0,0},{0,0,0},{0,0,0}}
               0 1 2   0 1 2   0 1 2
                0        1        2
           */
        
         new int[3][] //创建一个长度为3的二维数组,其中每一个一维数组的值为空(null)
   
           /*
             二维数组遍历
             循环每次取出二维数组中的第i个

            */
        int[][]b=new int[][]{{1,2,3},{1,2,3},{1,2,3}};
         
         for (int i = 0; i < b.length; i++) {
            //遍历每次取出的一维数组
            for (int j = 0; j <b[i].length; j++) {
                System.out.print(b[i][j]+"\t");
            }
            System.out.println();//换行
        }

    }

稀疏数组
/*稀疏数组
   * 含义：稀疏数组一般是将一个数组中有意义的值的信息存放在另一个数组中。
    结构:  列数一般为3，分别表示横向下标，纵向下标，值.(第二行开始)
          第一行一般存原始数组的行数，原始数组的列数，以及有意义的值的个数。根据情况可以调整
    优点：可以对数据进行压缩。*/
    public static void main(String[] args) {
        //定义一个二维数组
        System.out.println("原数组:");
        int[][]a=new int[9][9];
        a[1][2]=1;
        a[2][1]=2;
        a[3][3]=3;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                System.out.print(a[i][j]+"\t");
            }
            System.out.println();
        }
        
        //稀疏数组
        int t=0;//定义一个值判断有用的个数
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                if (a[i][j]!=0){
                    t++;
                }
            }
        }
        
        //创建一个稀疏数组
        int[][]x=new int[t+1][3];
        x[0][0]=a.length;
        x[0][1]=a[0].length;
        x[0][2]=t;
        
        //将有用的数存放到稀疏数组中
        int c=1;//用来记录稀疏数组中每行的数据
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                if (a[i][j]!=0){
                   x[c][0]=i;
                   x[c][1]=j;
                   x[c][2]=a[i][j];
                   c++;
                }
            }
        }
        
        //打印稀疏数组
        System.out.println("稀疏数组:");
        for (int i = 0; i < x.length; i++) {
            for (int j = 0; j < x[i].length; j++) {
                System.out.print(x[i][j]+"\t");
            }
            System.out.println();
        }
        
        //将稀疏数组转化为所对应的数组
          //创建新数组
        int[][]a2=new int[x[0][0]][x[0][1]];
          //将有用的数传入数组
        int c1=1;
        for (int i = 0; i < a2.length; i++) {
            for (int j = 0; j <a2[i].length ; j++) {
                if (i==x[c1][0]&&j==x[c1][1]){
                    a2[i][j]=x[c1][2];
                    if (c1==t)break;//防止超出稀疏数组
                    c1++;
                }
            }
        }
        
        //打印新数组
        System.out.println("新数组为:");
        for (int i = 0; i < a2.length; i++) {
            for (int j = 0; j < a2[i].length; j++) {
                System.out.print(a2[i][j]+"\t");
            }
            System.out.println();
        }

    }

二维数组的创建:
//数组创建
int arr[3][4];	//长度为3的一维数组,每个元素又是长度为4
char arr[3][5];
double [2][4];
//数组初始化
int arr[3][4] = {1,2,3,4};
int arr[3][4] = {{1,2},{4,5}};
int arr[][4] = {{2,3},{4,5}};

我们一定要注意在二维数组的创建和初始化中只有第一个[]中的数字可以省略,其他[]中不可以.

二维数组本质上也是一个一维数组,只不过每个元素又是一个一维数组.

二维数组的使用也是通过下标的方式.比如下面这个例子:
#include <stdio.h>
#include <stdlib.h>
int main(){
	int i;
	int j;
	int arr[3][4] = { 0 };	//创建一个二维数组,并将其元素初始化为0
	for (i = 0; i < 3; ++i){
		for (j = 0; j < 4; ++j){
			arr[i][j] = i * 3 + j;	//给二维数组中的元素赋值
		}
	}
	for (i = 0; i < 3; ++i){
		for (j = 0; j < 4; ++j){
			printf("%d ",arr[i][j]);	//打印出二维数组中所有的元素
		}
	}
	system("pause");
	return 0;
}



二维数组在内存中的存储

之前我们已经了解过了一维数组在内存中的存储,所以,类似的,我们尝试将二维数组的每个元素的地址打印出来.
#include <stdio.h>
#include <stdlib.h>
int main(){
	int i,j;
	int arr[3][4];
	for (i = 0; i < 3; ++i){
		for (j = 0; j < 4; ++j){
			printf("&arr[%d][%d] = %p\n",i,j,&arr[i][j]);
		}
	}
	system("pause");
	return 0;
}

结果如图:



不难看出,二维数组在内存中也是连续存储的.