Beginning Python Chapter2

• 在python中，最基本的数据结构是序列，序列中的每一个元素被分配一个序号，即元素的位置，也称为索引，第一个索引是0，第二个索引是1，一次类推，序列中的最后一个元素标记为-1, 倒数第二个元素标记为-2，以此类推。python中有6中内建的序列，最常用的是 列表 和 元组 列表和元组的主要区别在于，列表可以修改，元组不能修改，一般来说几乎在说有情况下都可以使用列表替换元组。另外一点比较重要的是python中的序列可以嵌套。

  列表嵌套列表

  lst = []
  a = [1,2,3]
  b = [4,5,6]
  lst.append(a)
  lst.append(b)
  print lst
  输出：[[1,2,3],[4,5,6]]

  列表嵌套字典
  
lst = []
a = {'a' : 1, 'b' : 2}
b = {'c' : 3, 'd' : 4}
lst.append(a)
lst.append(b)
print lst
输出： [{'a' : 1, 'b' : 2}, {'c' : 3, 'd' : 4}]


• 所有的序列都可以进行某些特定的操作，这些操作包括:索引，分片，加，乘 以及检查某个元素是否属于序列，除此之外python还有计算长度，找出最大元素和最小元素的内建函数。

  操作	描述
  索引	根据位置得到序列的元素
  分片	得到序列的子集
  相加	多个序列相加得到一个新的序列
  相乘	序列与整数相乘得到新的序列
  检查	检查某个元素是否在序列中
  长度	得到序列的长度
  最值	得到序列中的最大最小值

• 索引
  序列中的所有元素都是有编号的，从0开始递增，这些元素都可以通过编号来访问，序列支持负数作为索引，当使用负索引时，python会从右向左访问元素，也就是从最后一个元素向前访问，最后一个元素的位置编号是 -1 而不是 -0，因为-0会和第一个元素重合。

lst = [1, 2, 3]
print lst[0], lst[1], lst[2]
print lst[-1], lst[-2], lst[-3]
print lst[0 - len(lst)], lst[1 - len(lst)], lst[2 - len(lst)]
输出: 1 2 3   3 2 1   1 2 3 

• 分片
  分片是获取序列子序列的一种方法，索引是当问的是单个元素，而分片可以访问一定范围的元素，分片是通过冒号:相隔两个索引来实现， 即得到两个索引之间的数据，需要注意的是，切片访问的数据范围前闭后开。类似于数据上的[ ), 下面是一个分片的例子

  lst = [1, 2, 3, 4, 5]
  a = lst[1 : 2]
  b = lst[-1 : -2]
  c = lst[3 : 1]
  d = lst[-100 : 2]
  e = lst[1 : -2]
  f = lst[-2 : -1]
  print a, b, c, d, e, f
  输出: [2], [], [], [1,2], [2, 3], [4]

  对于步长为正数的分片操作可以这样理解：
  只要分片最左边的索引比最右边的晚出现在序列中，那这样的结果就是得到一个空的序列，即当左边的索引小于右边的索引时才能得到具有元素的序列 （L<= R）

  a: 左边索引位置1， 右边索引位置2， 1比2先出现在索引中，所以不是空集合，根据规则结果为[2]
  b: 左边索引-1.即4， 右边索引-2即3， 4比3后出现在索引中，所以得到的是空集合 []
  c: 左边索引3， 右边索引1， 3比1后出现在索引中，所以得到空集合 []
  d: 左边索引-100，可以理解为索引位置0，右边索引2，所以得到0，1索引位置的值 [1, 2]
  e: 左边索引1， 右边索引-2即3， 1比3早出现在集合中，所以得到1，2索引位置的值[2, 3]
  f:左边索引-2即3，右边索引-1即4，3比4早出现在集合中，所以得到3位置的值， [4]

  lst = [1, 2, 3, 4, 5]
  a = lst[1 : 2 : -1]
  b = lst[-1 : -2 : -1]
  c = lst[3 : 1 : -1]
  d = lst[-100 : 2 : -1]
  e = lst[1 : -2 : -1]
  f = lst[-2 : -1 : -1]
  print a, b, c, d, e, f
  输出: [], [5], [4, 3], [], [], []

  对于步长为负数的分片操作可以这样理解：
  只要分片最左边的索引比最右边的索引早出现在序列中，即最左边的索引位置小，则得到一个空的集合，如果要得到有数值的索引，必须确保 L >= R
  对上面的例子进行分析：
  a: 1 < 2 所以结果为空集合
  b: -1 > -2 所以集合不为空，结果取-1索引位置开始取，取到-2结束，值 即[5]
  c: 3 > 1 所以集合不为空，结果从3位置开始取，取到1位置结束，即[4, 3]
  d:-100即为0，0 < 2 所以得到的是空集合
  e:-2对应的索引为3， 1 < 3 所以得到的是空集合
  f:-2 < -1 所以得到的是空集合

  序列的步长可正可负，但是不能是0,如果指定步长为0，则异常
  可以使用切片操作对序列进行反转，具体操作直接指定开始和结束为止，步长为-1
  如：

  lst = [1,2,3,4,5,6] 
  print lst[::-1]
  输出为[6,5,4,3,2,1]

• 相加
  序列支持下相加操作，可以将多个序列通过+拼接成一个新的序列，注意 不同类型的序列不能使用+进行拼接

  a = [1,2,3,4]
  b= [5,6,7]
  print a + b
  输出[1,2,3,4,5,6,7]

• 相乘
  序列支持乘法。这里所说的乘法并不是两个序列进行乘法操作，而是一个整数n * 一个序列
  序列乘以一个整数的结果是，这个序列的元素值会被重复n次

  lst = [1]
  lst *= 5
  print lst
  输出 [1,1,1,1,1]

• 检查
  这个检查其实就是判断一个元素是否在序列中。为了检查一个值是否在序列中可以使用in运算符，条件为真时返回True, 条件为假时返回False

lst = [1,2,3,4,5]
str = '12345'
print 1 in lst
print [1,2] in lst
print '1' in str
print '12' in str
print 1 in str
输出: True, False, True, True, Exception

最后一个输出会得到一个异常信息 TypeError:in <string> requires string as left operand, not int

• 长度
  我们可以使用len()函数获取任意序列的长度，当然也可以使用序列的内置属性__len__()函数
  
lst = [1, 2, 3, 4]
print len(lst)
print lst.__len__()
两个函数输出结果相同都是4


• 最值
  求序列中最值的方法是使用min()和max()

  str = '123'
  lst = [1,2,3,4]
  print min(s)
  print max(s)
  print min(lst)
  print max(lst)
  输出：1 3 1 4

  对于求最值有一点需要注意的是：如果序列是嵌套的，那么min和max的返回值是什么呢？

  a = [1,[1],[1,1,1],[2]]
  print min(a)
  print max(a)
  输出结果1 [2]
  
  a = [1,[1],[1,1,1],2]
  print min(a)
  print max(a)
  输出结果1， [1,1,1]
  
  a = [1,[1],[1,1],2]
  print min(a)
  print max(a)

• 列表的基本操作，注意是列表而不是序列
  list() 函数， 将对象转换为列表，并不是所有的对象都可以直接转换为序列

  str = 'hello'
  print list(str)
  输出 ['h','e','l','l','o']
  
  a = 4
  print list(a)
  异常,提示 int object is not iterable

  list()函数适用于所有的序列。
  将序列拼接成字符串可以使用join函数

  print ''.join(list('hello'))
  输出 hello

• 列表赋值
  对列表进行赋值时，这个列表的索引必须存在，如果不存在则引发异常

      a = []
      a[1] = 1
      list assignment index out of range

• 列表删除
  列表删除可以使用del 语句来实现，但是同样的删除时候也有注意事项

a = [1,2,3,4,5]
del a[0]
print a
for item in a:
    del item
for i in range(len(a)):
    del a[i]
print a

这段代码 第一个del操作将1从列表中删除，出去，接下来的循环并没有删除列表中的任何数据，最后一个循环，执行时会报错，因为删除时候列表的索引发生了变化，所以这段代码的输出结果是
[2,3,4,5]
[2,3,4,5]
IndexError:list assignment index out of range

• 分片赋值
  在重申一遍列表和元组的区别在于列表是允许修改的，而元组不允许修改，对列表的修改可以通过切片来实现，具体切片赋值方式和切片操作一样，程序可以一次为多个元素赋值，也可以在不替换任何元素的情况下插入新元素,也可以通过分片来删除元素

a = [1,2,3,4]
a[1:3] = ['a', 'b', 'c', 'd']
print a
[1, 'a', 'b', 'c', 'd', 4]

a = [1,2,3,4]
a[1:1] = ['a', 'b', 'c', 'd']
print a
[1, 'a', 'b', 'c', 'd',2,3, 4]
a[1:-1] = []
print a
[1,4]

• 列表的方法

函数	描述
append	向列表中追加元素
extend	扩展列表，可以使用其他的列表作为参数,效果和+=一样，但是效率要高很多
count	统计参数在列表中出现的次数
index	得到参数在序列中的索引，当参数不在序列中时，抛出异常
insert	在指定位置之前，插入参数,第一个参数为位置，第二个参数为要插入的对象
pop	删除指定位置的元素，并返回删除的元素，如果没有指定参数，默认删除最后一个，当要删除的位置不存在时，则报错，del也是如此
remove	移除列表中参数值的第一个匹配项，同样的当remove一个不存在的值时也会发生异常
reverse	将序列中的元素反向存放，在原始数据的基础上进行修改
sort	用于在原始位置上对列表进行排序
sorted	返回一个列表排序的副本，并不在原始列表的基础上进行排序

• 元组
  元组和列表一样也是序列的一种，但是元组不允许改变，如果要创建一个只有一个元素的元组，直接用一个括号是不够的，需要加上一个逗号。
  a = (1) 这样定义出来的a 仅仅是一个int型的对象，如果需要定义成元组，需要 a = (1,),因为元组不能修改，所以元组没有append的方法，tuple可以将对象转换成一个元组，同样的int型的对象也不能转换为元组，报错信息也是 int object is not iterable