闲话Python编程-数组

        大学数学有一门基础课叫线性代数，其中有一个基础知识点就是：矩阵。最简单理解就是一堆有关联的数值，我们可以对其进行某种运算，如加减乘除等。

        高中数学有数列这个知识点，就是按照一定次序排序的一列数；还有排列和组合，都是讲一堆数，怎么去发现其关联关系，怎么对它施加各种运算。

        计算机既然来源于数学，解决数学中一些计算问题，对上面讲的知识点也就有一个解决的知识点，那就是数组。

        C,C++,Java等语言里是直接有数组这个数据结构的，而且是语言直接原生支持。Python与众不同，没有直接叫数组的定义，而是叫序列类型Sequence Types:  list, tuple, range。

        list是可修改的序列，tuple是不可修改的序列，range是一个不可修改的数值序列，主要是给for循环使用的。

1. List类型

        list是一个可修改的序列，有4种方式来创建一个序列：

        1）空序列：

                s = []

        2）用常量或变量来初始化一个序列：  

                s1 = [1]
                s2 = ['a', 'b', 'c']
                s3 = [a, b, c]

        3）使用一个迭代器来创建一个序列：

                s = [x for x in iterable]

        上面的iterable是一个迭代器，后面会讲到，暂时知道有这么一个情况就行。

        4）用语言内置函数list来定义：

                s1 = list()

                s2 = list(iterable)

学习编程知识点，随时来一段代码验证：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# 练习List
 
 
def main():
    s1 = []
    print(s1)
 
    s2 = [1]
    print(s2)
 
    s3 = [1, 2, 3]
    print(s3)
 
    s4 = [x for x in [4, 5, 6, 7]]
    print(s4)
 
    s5 = list()
    print(s5)
 
    s6 = list(['a', 'b'])
    print(s6)
 
 
if __name__ == '__main__':
    main()

2. Tuple类型

        tuple是一个不可修改的序列，也有4种方式来创建：

        1）空序列：

                t = ()

        2）用一个逗号来创建单个值的序列：

                t1 = a,

                t2 = (a,)

        3）用多个逗号来创建序列：

                t1 = a, b, c

                t2 = (a, b, c)

        4）使用内置函数tuple()来创建序列：

                t1 = tuple()

                t2 = tuple(iterable)

        学习编程知识点，随时来一段代码验证：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# 练习Tuple
 
 
def main():
    t1 = ()
    print(t1)
 
    t2 = 1,
    print(t2)
 
    t3 = (2,)
    print(t3)
 
    t4 = 1, 2, 3
    print(t4)
 
    t5 = (1.1, 1.2, 1.3)
    print(t5)
 
    t6 = tuple()
    print(t6)
 
    t7 = tuple([4, 5])
    print(t7)
 
    for method in dir(tuple):
        print(method)
 
 
if __name__ == '__main__':
    main()

3. Range类型

        range类型是一个不可修改的序列类型，主要给for循环提供一个步长操作的。

        它的初始化只有2种：

        x1 = range(stop)

        x2 = range(start, stop, [, step])

        不指定start, 默认start是0， 不指定step，默认step是1。

        学习编程知识点，随时来一段代码验证：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# 练习range
 
 
def main():
    x1 = range(10)
    for n in x1:
        print(n)
 
    print('-------------------------------------')
    x2 = range(5, 10, 2)
    for n in x2:
        print(n)
 
 
if __name__ == '__main__':
    main()

执行结果：

0
1
2
3
4
5
6
7
8
9
-------------------------------------
5
7
9 

4. 序列的通用操作

        上面操作是所有序列都具有的操作，也就是List, Tuple和Range类型对象都可以具有的操作，注意到没有，它们都是获取、查询类操作，并没有修改类的操作，因为也是不可修改的序列能够操作的，下面来一段代码验证：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# 练习序列的通用操作
 
 
def main():
    s = [1, 2, 3, 4]
    if 1 in s:
        print('1 is in s')
 
    if 10 not in s:
        print('10 is not in s')
 
    t = [5, 6, 7]
    s1 = s + t
    print(s1)
 
    s2 = s * 2
    print(s2)
    s3 = 2 * s
    print(s3)
 
    print(s[0], s[3])
    print(s[0:3])
    print(s[0:4:2])
 
    print(len(s))
    print(min(s))
    print(max(s))
 
    print(s.index(2))
    print(s.index(2, 1))
    print(s.index(3, 0, 3))
 
    print(s1.count(1))
    print(s2.count(3))
 
 
if __name__ == '__main__':
    main()

 5. 可修改序列的特有操作

        可修改序列的特有操作，这些操作都是对序列本身内容进行了增删改的操作。

         还是来一段测试验证代码吧：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# 练习序列的通用操作
 
 
# 测试不可变操作
def test_immutable_operation():
    s = [1, 2, 3, 4]
    if 1 in s:
        print('1 is in s')
 
    if 10 not in s:
        print('10 is not in s')
 
    t = [5, 6, 7]
    s1 = s + t
    print(s1)
 
    s2 = s * 2
    print(s2)
    s3 = 2 * s
    print(s3)
 
    print(s[0], s[3])
    print(s[0:3])
    print(s[0:4:2])
 
    print(len(s))
    print(min(s))
    print(max(s))
 
    print(s.index(2))
    print(s.index(2, 1))
    print(s.index(3, 0, 3))
 
    print(s1.count(1))
    print(s2.count(3))
 
 
# 测试可变操作
def test_mutable_operation():
    s = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    s[3] = 33
    print(s)
 
    t = (21, 22, 23)
    s[1:2] = t
    print(s)
 
    del s[1:3]
    print(s)
 
    s[2:7:2] = [102, 104, 106]
    print(s)
 
    s.append(100)
    print(s)
 
    s.clear()
    print(s)
 
    s = [1, 2, 3, 4]
    x = s.copy()
    print(x)
 
    t = [5, 6, 7, 8]
    s += t
    print(s)
 
    s *= 2
    print(s)
 
    s.insert(2, 20)
    print(s)
 
    s.pop(10)
    print(s)
    s.pop()
    print(s)
 
    s.remove(7)
    print(s)
 
    s.reverse()
    print(s)
 
 
def main():
    # test_immutable_operation()
    test_mutable_operation()
 
 
if __name__ == '__main__':
    main()

        上面的函数test_mutable_operation（）就是测试可变序列的操作，大家可以去执行看看，想想是怎么回事。 

6. 结束语

        关于Python序列讲的比其它数据类型多得多，因为数组是一个非常常用的数据结构，而序列List是一个可以看成可变长度的数组，在现实编程中使用特别多，了解越熟悉越好。

        在序列List基础上，我们可以实现栈Stack，还可以实现队列Queue，多维数据也可以实现。

        记住，Pascal编程语言之父的名言：数据结构 + 算法 = 程序。

        记住，《Unix编程艺术》中Rob Pike提出的其中一个原则是：数据压倒一切；如果已经选择了正确的数据结构并把一切都组织的井井有条，那么正确的算法也就不言自明；编程的核心是数据结构，而不是算法。

        Python编程语言容易学习，并不代表数据结构和算法容易学习，这里的容易学习是指Python帮我们封装实现了很多技术细节，不用向C和C++那么苦逼地自己去实现，但是我们一定要去理解背后的知识原理，不然我们面对简单的程序可能都处理不好。

        陆游有诗句云：汝果欲学诗，工夫在诗外。真正要去编程，仅仅学习Python语言本身还是不行的。