Python学习笔记之列表

什么是列表？
列表是序列类型中的一种数据结构。使用中括号[]包裹的一系列数据元素的集合。
如何定义一个列表？
一般形式：
x = [] 或 y = [元素1，元素2，元素3,...] 或 z = [None] 或 m = list()  # 使用工厂函数list创建一个空列表
列表的特点：
a、用[]包裹；
b、元素间用逗号‘，’分隔；
c、元素的类型可以是任意的数据类型（如：数值，字符串，列表，元祖，字典等等）；
d、元素是有序排列的，可以通过索引和分片（切片）来获取某个元素值。
列表的常见操作：
1、通用序列操作：
A、索引（正向索引是从0开始计数的，反向索引是从-1开始的）
  操作符：[]
  一般形式：
    [元素1，元素2， 元素3， 元素4，... ， 元素n-1， 元素n]
正--->  0     1       2       3             n-2     n-1
          -n   -n+1    -n+2     -n+3  ...       -2     -1  <---反 
   如： alist = [123, 'name', ['age', 'male']]
        ①正向索引（从左向右）：
        alist[0] ---> 123 
        alist[1] ---> name
        alist[2] --->['age', 'male']
       ②反向索引（从右向左）
       alist[-1] ---> ['age', 'male']
       alist[-2] ---> name
       alist[-3] ---> 123

B、分片（切片,连续取一片值，返回一个列表）
  操作符：[:] 或 [::]
  特点：
  a、顾头不顾尾（即分片取值的时候，包括第一个start_index索引号对应的值，不包括end_index索引号对应的值）
  b、start_index对应的元素比end_index对应的元素出现的晚并且是正向索引的话，结果就是一个空序列。
    一般形式：
    [start_index : end_index] 或 [start_index : end_index : step_value]
如： alist = [123, 'name', ['age', 'male'], ('name', 'age')]
   ①正向索引（从左向右）：
         alist[0:1] ---> [123]
         alist[1:3] ---> ['name', ['age', 'male']]
         alist[:]   ---> [123, 'name', ['age', 'male'], ('name','age')]
         alist[-3:-1] ---> [123, ['age', 'male']
         alist[0:-1] ---> [123, 'name', ['age', 'male']]
         alist[0:3:2] ---> [123, ['age', 'male']]  # 更大的步进
         alist[::4] ---> [123] #步进超出索引
  ②反向索引（从右向左）
         alist[::-1] ---> [('name', 'age'), ['age', 'male'], 'name',123]
         alist[3:0:-1]  ---> [('name', 'age'), ['age', 'male'], 'name']
         alist[-1:-3:-1] ---> [('name, 'age'), ['age', 'male']]
         alist[-1:0:-1] ---> [('name', 'age'), ['age', 'male'], 'name']
         alist[2:0:-1] ---> [['age', 'male'], 'name']
         alist[-1:-4:-2] ---> [('name', 'age'), 'name']# 更大的步进
         alist[-1:-4:-4] ---> [('name', 'age')] #步进超出索引范围
 
C、列表相加 '+'
  操作符： +
  功能特点：
  把两个列表的元素组合在一起，生产一个新列表。
  x = [1,2,3]
  y = [4,5,6]
  x + y ---> [1,2,3,4,5,6] 
  m = ['name',[123,'male'],('age', 'hat')] 
  n = [12, ('men', 'data'), '40']  
  m + n = ['name', [123, 'male'], ('age', 'hat'), 12, ('men', 'data'), '40']
  
D、列表相乘 '*'或叫重复操作符
  操作符： *
  一般形式：[]*n
  功能特点：
  生成一个新列表，原有的列表数据被重复n次。
  如：alist = ['name', 'age']*3 ---> ['name', 'age', 'name', 'age', 'name', 'age']
  
F、成员资格
  操作符：in 和 not in
  一般形式： 'name' in ['name', 'male'] 或　'man' not in ['name', 'male']
  功能特点： 检查某个值是否在列表中。是返回True，否返回False。
  如：
  'name' in ['name', 'male'] ---> Ttrue
  'name' not in ['name', 'male'] --->False
  'age' in ['name', 'male'] ---> False
  'age' not in ['name', 'male'] ---> True
  
G、长度、最小值、最大值
  操作符：len()、min()、max()
  一般形式：len(object)、min(object)、max(object)
  功能特点：
  len(object) ---> object的长度
  min(object) ---> object的最小值
  max(object) ---> object的最大值
  如：
  len(['name', 'age', ['male', 123], 123]) ---> 4  # 返回列表元素个数
  len('hello world') ---> 11  # 返回字符串的字符数量
  min(['name', 'age', ['male', 123], 123]) ---> 123 
  min('hello world') ---> ' '
  min(4,1,3,0,9) ---> 0
  min('a',1,'l','k',9) ---> 1
  max(['name', 'age', ['male', 123], 123]) ---> 'name'
  max('hello world') ---> 'w'
  max(4,1,3,0,9) ---> 9
  max('a',1,'l','k',9) ---> 'l'
  
2、列表更新：更改元素值
  操作符： =
  一般形式： alist[index] = 更改后的值 或 alist[start_index:end_index:step_value] = (value1, value2, ...)/[value1, value2, ...]
  功能特点：
  通过在等号'='的左边指定一个索引或索引范围的方式来更改一个或几个元素的值，或者叫元素赋值和分片赋值
  注意点：
  a、alist[index] = 更改后的值 这种形式更改值时，若index超出了列表本身索引范围时，会发生异常（IndexError: list assignment index out of range）：
        >>> alist = [1,2]
        >>> alist
        [1, 2]
        >>> alist[2]=3

        Traceback (most recent call last):
            File "<pyshell#28>", line 1, in <module>
            alist[2]=3
        IndexError: list assignment index out of range
  b、alist[start_index:end_index:step_value] = (value1, value2, ...)/[value1, value2, ...] 更改列表元素值时，
        若索引范围元素个数小于或大于更改后值的个数时，将更改后的值以开始的索引把更改后的值插入到列表中。
        ①小于的情况
>>> alist
        [1, 2]
        >>> alist[0:2] = [7,8,9,0]
        >>> alist
        [7, 8, 9, 0]

>>> alist = [1,2]
        >>> alist
        [1, 2]
>>> alist[0:1] = [7,8,9,0]
        >>> alist
        [7, 8, 9, 0, 2]
        ②大于的情况  
>>> alist = [1,2,3,4,5,6]
        >>> alist
        [1, 2, 3, 4, 5, 6]
        >>> alist[0:3] = [8,9]
>>> alist
        [8, 9, 4, 5, 6]
  
3、列表更新：删除元素
  操作函数：del 或 alist[:] =[] 分片赋值方法
  一般形式：del alist[index] 或 del alist[:] 或 del alist
  功能特点：
    删除某个元素值或列表
  如：
    >>> alist
    [8, 9, 4, 5, 6]
    >>> del alist[0]
    >>> alist
    [9, 4, 5, 6]

>>> alist = [8,9,4,5,6]
    >>> alist
    [8, 9, 4, 5, 6]
    >>> del alist[0:2]
>>> alist
    [4, 5, 6]

    >>> del alist
    >>> alist

    Traceback (most recent call last):
      File "<pyshell#48>", line 1, in <module>
       alist
    NameError: name 'alist' is not defined

4、列表的内建方法
  a、alist.append()  # 在列表的末尾追加新对象，接受一个参数
    >>> alist = [1,2,3]
    >>> alist.append(4)
    >>> alist
    [1, 2, 3, 4]
    
  b、alist.count()  # 统计某个元素在列表中出现的次数，接受一个参数
    >>> alist = [[1,2], 1,1,[2,1,[1,2]]]
    >>> alist.count(1)
    2
    >>> alist.count([1,2])
    1
  c、alist.extend()  # 在列表的末尾一次性追加另一个序列中的多个值，接受一个参数
    >>> alist = [1,2,3]
    >>> alist1 = [4,5,6]
    >>> alist.extend(alist1)
    >>> alist
    [1, 2, 3, 4, 5, 6]
    
  d、alist.index(value, [start,[stop]])  # 此方法用于从列表中找出某个值第一个匹配项的索引位置，如果不存在，则引发ValueError异常。start/stop指定在查找的索引范围。
    >>> alist = ['name', 'age', 'male']
    >>> alist.index('age')
    1
    >>> alist.index('male')
    2
    >>> alist.index('allen')

    Traceback (most recent call last):
        File "<pyshell#6>", line 1, in <module>
            alist.index('allen')
    ValueError: 'allen' is not in list
    
  e、alist.insert(index, object)  # 在指定的索引位置插入对象。此方法也可以用分片赋值的方式来实现。
    >>> alist = ['name', 'age', 'male']
    >>> alist.insert(1,'allen')
    >>> alist
    ['name', 'allen', 'age', 'male']
    
  f、alist.pop([index])  # 移除并返回指定索引位置的值，默认移除并返回最后一个列表元素。如果列表为空或指定的索引值超出了alist的索引范围，则引发一个IndexError。
     >>> alist = ['name', 'age', 'male']
    >>> alist.pop()
    'male'
    >>> alist
    ['name', 'age']
    >>> alist.pop(1)
    'age'
    >>> alist
    ['name']
    >>> alist = []
    >>> alist.pop()

    Traceback (most recent call last):
        File "<pyshell#23>", line 1, in <module>
            alist.pop()
    IndexError: pop from empty list 
    
  g、alist.remove(value)  # 移除列表中第一个出现的value元素，如果value不存在，则引发ValueError。
    >>> alist = ['name', 'age', 'male', 'age']
    >>> alist.remove('age')
    >>> alist
    ['name', 'male', 'age']
    >>> alist.remove('allen')

    Traceback (most recent call last):
        File "<pyshell#29>", line 1, in <module>
            alist.remove('allen')
    ValueError: list.remove(x): x not in list
    注意：remove方法是一个没有返回值的原位置改变方法。
    
  h、alist.reverse()  # 将列表中的元素反向存放（或叫排序）
>>> alist = ['name', 'age', 'male']
    >>> alist.reverse()
    >>> alist
    ['male', 'age', 'name']
    注意：reverse方法也改变了列表但不返回值。
    
  i、alist.sort(cmp=None, key=None, reverse=False)  # 在原位置对列表进行排序（注：会改变原来的列表）。
>>> alist = ['name', 'age', 'male']
    >>> alist.sort()
    >>> alist
    ['age', 'male', 'name']

5、列表的内建函数
  a、cmp(x, y)  # 若x<y 返回 -1，若x==y 返回 0 ，若x>y 返回 1。
     比较算法：
        对两个列表的元素进行比较；
        如果比较的元素是同类型的，则比较其值，返回结果；
        如果两个元素不是同一类型，则检查它们是否是数字：
            如果是数字，执行必要的数字强制类型转换，然后比较；
            如果有一方的元素是数字，则另一方的元素“大”（数字是“最小的”）；
            否则，通过类型名字的字母顺序进行比较；
        如果有一个列表首先达到末尾，则另一个长一点的列表“大”；
        如果我们用尽了两个列表的元素而且所有元素都是相等的，那么结果就是返回一个0.
        
  b、len()  # 返回列表的元素个数。
    >>> alist = ['name', 'age', 'male']
    >>> len(alist)
    3
    
  c、max() 和 min()  #返回列表元素的最大值和最小值。
  d、sorted(iterable, cmp=None, key=None, reverse=False)  # 对iterable进行排序并返回列表的副本，不会改变原列表。
    >>> alist = ['name', 'age', 'male']
    >>> sorted(alist)
    ['age', 'male', 'name']
    >>> alist
    ['name', 'age', 'male']
    
  e、reversed()  # 对列表进行反向排序，返回一个迭代对象，用list()函数这个迭代对象转换成一个列表。
    >>> alist = ['name', 'age', 'male']
    >>> reversed(alist)
    <listreverseiterator object at 0x0000000002A65B70>
    >>> list(reversed(alist))
    ['male', 'age', 'name'] 
    
  f、enumerate()  # 返回一个可迭代对象的索引和值。
    >>> alist = ['name', 'age', 'male']
    >>> enumerate(alist)
    <enumerate object at 0x0000000002A567E0>
    >>> list(enumerate(alist))
    [(0, 'name'), (1, 'age'), (2, 'male')]
    >>> for i, j in enumerate(alist):
print i,j

    0 name
    1 age
    2 male
    
  g、zip()  # zip(seq1 [, seq2 [...]]) -> [(seq1[0], seq2[0] ...), (...)]
    >>> alist = ['name', 'age', 'male']
    >>> alist1 = ['allen', 40, 'man']
    >>> zip(alist, alist1)
    [('name', 'allen'), ('age', 40), ('male', 'man')]
    
    >>> for m, n in zip(alist, alist1):
print m,n
    name allen
    age 40
    male man
    
  h、sum()  # sum(sequence[, start]) -> value ;star 默认值为0，如果列表为空，返回start。
    >>> alist = [1,2,3,4]
    >>> sum(alist)
    10
    >>> sum(alist, 1)
    11
    >>> alist=[]
    >>> sum(alist)
    0
    >>> sum(alist, 4)
    4
    
  i、list()  #创建或转换一个可迭代对象为列表。
    >>> x = list()
    >>> x
    []
    >>> y = list('hello world')
    >>> y
    ['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']