python基础教程(第2版)第二章读后总结；

python第二章

序列是一种数据结构：典型的序列包括：列表，字符串，元组

  数据结构是通过某种方式（例如对元素进行编号）组织在一起的数据元素的集合，这些数据元素

  可以是数字或者字符，甚至可以是其他数据结构，在python中，最近本的数据结构是序列，序列中的每个元素被

  分配一个序号-----即元素的位置，也成为索引，第一个索引是0，第二个则是1，以此类推。

列表和元组的主要区别：

列表可以修改，元组则不能，但他们都统称为序列;
列表的各个元素通过逗号分离，写在方括号中；
元组的各个元素通过逗号分离，写在圆括号中；
元组可以在映射中当作键使用，而列表则不行；
元组作为很多内建函数和方法的返回值存在，也就是说你必须对元组进行处理，只要不尝试修改元组
那么处理元组在绝大多数情况下就是把他们当作列表来进行操作；
一般来说，列表更能满足对序列的所有要求；

       序列也可以包含其他的序列；如

In [10]: lambert = [‘age‘,20]
In [11]: lizheng = [lambert,‘hello‘]
In [12]: print lizheng
[[‘age‘, 20], ‘hello‘]

Python中还有一个名为容器的数据结构。

容器基本上是包含其他对象的任意对象，序列（例如列表和元组）和映射（例如字典）是两类主要的容器。
序列中的每个元素都有自己的编号，而映射中的每个元素则有一个名字（也称为键）通用序列操作：
所有的序列类型都可以进行某些特定的操作，比如说：索引，分片，加，乘以及检查某个元素是否属于序列的成员，除此之外，python还有计算序列长度，找出最大元素和最小元素的内建函数；

Python中成员资格检查用IN：这个运算符检查条件是否为真，然后返回相应的值，

   条件为真返回True，条件为假返回False。

例如：

In [19]: aa = "lambert"
In [20]: ‘lam‘ in aa
Out[20]: True

这章所设计的几个函数跟方法，下面将围绕这幅图进行说明；

1.内建函数len，min和max非常有用；

    len函数返回序列中所包含元素的数量

    min函数返回序列中最小的元素

    max函数返回序列中最大的元素

In [1]: numbers = [1,168,888]
In [2]: len(numbers)
Out[2]: 3
In [3]: max(numbers)
Out[3]: 888
In [4]: min(numbers)
Out[4]: 1

list函数，可以拆分字符串为列表，有时候很有用，适合所有类型的序列；

In [5]: aa = ‘lambert‘
In [6]: list(aa)
Out[6]: [‘l‘, ‘a‘, ‘m‘, ‘b‘, ‘e‘, ‘r‘, ‘t‘]

2.append方法用于在列表末尾追加新的对象，只是在恰当位置修改原来的列表，这意味着，它不是简单地返回一个修改过的新列表----而是直接修改原来的列表，一般来说这不是我们想要的。

In [7]: lst = [1,2,4]
In [8]: lst.append(6)
In [9]: print lst
[1, 2, 4, 6]

3.count方法统计某个元素在列表中出现的次数

In [10]: times = [1,2,3,4,5,6,2]
In [11]: times.count(2)
Out[11]: 2
In [12]: times.count(4)
Out[12]: 1

4.extend方法可以在列表的末尾一次性追加另一个序列中的多个值，换句话说，可以用新列表扩展原有的列表；

In [13]: a = [1,2,3]
In [14]: b = [4,5,6]
In [15]: a.extend(b)
In [16]: print a
[1, 2, 3, 4, 5, 6]

上面这种操作看起来像连接操作，两者最重要区别在于：extend方法修改了被扩展的序列

，而原始的序列操作（即连接操作）则不然，它会返回一个全新的列表；

5.index方法用于从列表中找出某个值第一个匹配项的索引位置；

In [22]: lambert = [‘light‘,‘orange‘,‘via‘,‘enough‘]
In [23]: lambert.index(‘orange‘)
Out[23]: 1
In [24]: lambert[1]
Out[24]: ‘orange‘

  insert方法用于将对象插入到列表中：

In [27]: numbers = [1,2,3,4,5,6]
In [28]: numbers.insert(3,‘three‘)
In [29]: print numbers
[1, 2, 3, ‘three‘, 4, 5, 6]

当然，它与extend方法一样，也可以实现分片赋值；例如：

In [41]: numbers = [‘one‘,‘two‘,‘three‘,‘four‘,‘five‘]
In [42]: numbers[3:4] = [‘Hello‘]            //1，与下比较  替换four本身，five之前；

In [43]: numbers
Out[43]: [‘one‘, ‘two‘, ‘three‘, ‘Hello‘, ‘five‘]    //你可能在想，我想替换four和five，为什么没有生效呢？

In [44]: numbers[3:5] = [‘Hello‘]            //2，与上比较，因为如果分片的话打印，打印索引5之前的，索引3之后的（包括3）

In [45]: numbers
Out[45]: [‘one‘, ‘two‘, ‘three‘, ‘Hello‘]

6.pop方法会移除列表中的一个元素，默认是最后一个，并且返回改元素的值；

     pop方法是唯一一个既能修改列表又返回元素值（除了None）的列表方法；

     使用pop方法可以实现一种常见的数据结构----栈，栈的原理就像堆放在盘子一样，只能在顶部放   盘子，同样，也只能从顶部拿走盘子，最后被放入堆栈的最先被溢出，这个原则成为LIFO,即后进先出；

  举个例子：

In [46]: x = [1,2,4]
In [47]: x.pop()
Out[47]: 4
In [48]: x
Out[48]: [1, 2]                     //4被踢出来了
In [49]: x.append(x.pop())
In [50]: x
Out[50]: [1, 2]                    //2还在，我踢出来之后再用append追加进去；

7.remover方法用于移除列表中某个值的第一个匹配项；

In [51]: x = [‘hello‘,‘lambert‘]
In [52]: x.remove(‘lambert‘)
In [53]: x
Out[53]: [‘hello‘]

 reverse方法将列表中的元素反向存放；从单词字面一次都可以看出来吧；

In [54]: x = [1,2,3]
In [55]: x.reverse()
In [56]: x
Out[56]: [3, 2, 1]

8.sort方法用于在原位置对列表进行排序，在原位置排序意味着改变原来的列表，从而让其中的元素能按一定的顺序排列，而不是简单地返回一个已排序的列表副本；

In [60]: aa = [2,45,1,34,2342,332]
In [61]: aa.sort()
In [62]: print aa
[1, 2, 34, 45, 332, 2342]

复制列表的快速方法：第一种方法，是切片赋值，第二种通过sorted函数；

In [70]: x = [1,454,2,34,3]
In [71]: y = x[:]           或者 y = sorted(x)   把x切片后的值给y
In [72]: y.sort()
In [73]: x
Out[73]: [1, 454, 2, 34, 3]
In [74]: y
Out[74]: [1, 2, 3, 34, 454]          //看到了吗，就是这么任性；

9.tuple函数的功能与list函数基本上是一样的，将一个序列作为参数并把它转换为元组；

In [81]: tuple([1,2,3])
Out[81]: (1, 2, 3)

本文出自 “leejung” 博客，请务必保留此出处http://leejung.blog.51cto.com/8917264/1605258