列表

列表：是可变的序列 
列表的 in / not in运算符 (成员身份验证运算符)

作用：
  判断一个值是否存在于列表中,存在返回True,不存在返回 False

  同字符串的in运算符相同.


示例：
  x = [1, "two", 3, "Four"]
  3 in x     # True
  3 not in x # False
  'two' in x # True


列表的索引操作:
语法:
  列表[整数表达式]
用法：
  等同于字符串的索引
  索引分正向索引和反向索引(同字符串)


示例：
  L = [1, 2, 3, 4]
  print(L[0])  # 1
  print(L[-1]) # 4
思考：
  如何让列表从后向前依次打印列表的值：
  # 正向的打印
  for x in L:
      print(x)
  # 反向打印:
  for x in L[::-1]:
      print(x)
  for i in range(3, -1, -1):
      print(L[i])


列表的索引赋值:
  列表是可变的序列，可以通过索引改变列表的元素
例：
  L = [1,2,3,4]
  L[2] = 3.14  # 索引赋值
  print(L)


对比字符串:
  L = [1,2,3,4]
  L += [5]  # 创建了新的列表，不是改变原列表
  print(L)  # 


  s = "ABCD"
  s += "E"
  print(s)


列表的切片
语法:
  列表[开始索引:终止索引: 步长]


列表的切片取值规则等同于字符串切片规则.
示例：
  x = [0,1,2,3,4,5,6,7,8]
  y = x[1:9:2]  # y = [1,3,5,7] 奇数 
  y = x[9:1:-2] # y = [8,6,4,2]
  x[::-2]


列表的切片赋值:
作用：
  可以改变原列表，可以插入和删除数据，也可以改变数据
说明：
  切片赋值的等号运算符的右侧必须是一个序列
语法：
  列表[(开始索引):(终止索引)(:(步长))] = 序列


示例:
  L = [2,3,4]
  L[0:1] = [1.1, 2.2] 


  L = [2,3,4]
  L[2:] = [3.3, 4.4, 5.5]
  
  L = [2,3,4]
  L[3:] = [5.5, 6.6]
  L = [2,3,4]  
  L[0:0] = [0, 1]  # [0, 1, 2, 3, 4]


  L = [2,3,4]  
  L[1:1] = [2.5, 2.6]
  # 删除数据
  L = [2,3,4]  
  L[1:] = []


  L = [2,3,4]
  L[1:2] = "ABC"     # L=[2, 'A', 'B', 'C', 4]
  L[1:2] = ["ABC"]     # L=[2, "ABC", 4]


对于步长大于1 的切片赋值:
  L = [1, 2, 3, 4, 5, 6]
  L[::2] = []    # 错的
  L[::2] = [1.1, 3.3, 5.5]    # L = [1.1, 2, 3.3, 4, 5.5, 6]


  L[::2] =[1,2,3,4]  # ????




说明：
  对于步长大于1的切片赋值，序列的个数要等于切出的段数


对于反向切片的赋值,规则同正向切片，同学们自己偿试


思考:
  L = [1, 2, 3, 4, 5, 6]
  能否将 1,3,5删除? 答案是用切片无法实现
  L[::2] = [[], [], []]


del 语句
  可以用del语句删除变量，也可以用它来删除列中的元素
语法:
  del 列表[整数表达式]   # 索引
  del 列表[::]         # 切片


示例：
  L = [1,2,3,4,5,6]
  del L[3]  # 结果 L = [1,2,3,5,6]
  L = [1,2,3,4,5,6]
  del L[::2]  # 结果 L = [2,4,6]




Python3中常用于序列的函数:
  len(seq)
  max(x)
  min(x)
  -----以上是我们以前学过的-----
  sum(x)  返回序列中所有元素的和(元素必须是数值类型)
  any(x)  真值测试,如果序列中其中一个值为真值则返回True,全为假返回False
  all(x)  真值测试，如果序列中所有值为真值返回True,否则返回False


示例:
  L = [1, 2, 3, 4, 6]
  len(L)  # 5
  max(L)  # 6
  min(L)  # 1
  L = [1, 2.0, 3.14]
  max(L)   # 对的 返回值为3.14
  L = [1, 2, "3"]
  max(L)   # 错的

常用的列表 方法 method:
  对象.方法名(传参)
  假设列表名为L


L.index(v[, begin[, end]])  返回对应元素的索引下标，begin为开始索引，end为结束索引
L.insert(index, obj) 将某个元素插入到列表中的指定位置
L.count(x) 返回列表中的元素个数
L.remove(x) 从列表中删除第一次出现在列表中的值
L.copy() 复制此列表(只复制一层，不会复制深层对象)
L.append(x)  向列表中追加单个元素
L.extend(lst) 向列表追加另一个列表
L.clear()  清空列表,等同于 L[:] = []
L.sort(reverse=False)  将列表中的元素进行排序，默认顺序按值的小到大顺序排列
L.reverse()  列表的反转，用来改变原列表的先后顺序
L.pop([index])  删除索引用对应的元素，如果不加索引，默认删除最后元素，同时返回删除的元素


详见: >>> help(list)


示例：
  L = [5, 7, 9, 3, 1]
  L2 = L.copy()  # L2 =  [5, 7, 9, 3, 1]
  L[2] = 10
  L2   # L2的值不变


  L = [1,2,3]
  L2 = L[:]  # 切片实现复制
  L[1] = 2.2
  L2  # L2 = [1,2,3]
  # append 和extend
  L = [1,2,3]
  L.append(4)  # L = [1,2,3,4]
  L.extend([5,6,7])  # L = [1,2,3,4,5,6,7]
  # 思考
  L = [1,2,3,4]
  L.append([5,6,7])  # L = [1,2,3,4,[5,6,7]]


  # 思考
  L = [1,2,3]
  L2 = L
  # L = []  # 这算清空列表吗？答：不算清空列表
  L[:] = []  # 同于L.clear()
  print(L2)  # [1,2,3]


  # 排序
  L = [5, 7, 9, 3, 1]
  L.sort()  # L = [1, 3, 5, 7, 9]
  L = [5, 7, 9, 3, 1]
  L.sort(reverse=True)  # L = [9,7,5,3,1]




列表与字符串比较:
  1） 列表和字符串都是序列，元素之间有先后关系
  2） 字符串是不可变的序列，列表是可变的序列
  3） 字符串中每个元素只能存储字符，而列表可以存储任意类型的元素
  4） 列表和字符串都是可迭代对象


  L = [1,2,3,4]
  for x in L:

     print(x)

列表推导式 (list comprehension)
作用：
　　用简易方法生成列表
语法
  [表达式 for 变量　in 可迭代对象]
  或
  [表达式 for 变量　in 可迭代对象 if 真值表达式]
说明：
　　1. 先用可迭代对象生成一个对象，同时用变量绑定这个对象
  2. 调用表达式, 把当前的表达式结果以追加方式存放于列表中
  3. 重复1步骤，直到可迭代对象不再提供数据为止
  4. for in 表达式的if 子句可以省略，省略后将对所有对象进行处理
  5. 如果 if真值表达式的布尔值为False,则可迭代对象生成的数据将被丢弃


示例：
　　　见: list_comprehesion.py
   # 生成一个列表:
     [1, 2, 3, 4, 5, 6, ..... , 10000]
    L = [x for x in range(1, 10001)]　 # 正确做法1
    L = [x + 1 for x in range(10000)] # 正确做法2


练习：
　　生成一个数值为1~9的平方的列表：
　　L = [1, 4, 9, 16, ...., 81]
　　用列表推导式实现
  L = [x ** 2 for x in range(1, 10)]


示例：
  # 生成奇数的列表
　　L = [x for x in range(100)　if x % 2 == 1]


练习：
　　生成一个列表：x的平方+1的列表,跳过结果能被5整除的数, 
   x<= 100
   L = [2, 5, 10, 17, ....]
   L = [2, 17, ....]
   L = [x ** 2 + 1 for x in range(1, 101)
              if (x ** 2 + 1) % 5]


   L = [x ** 2 + 1 for x in range(1, 101)
              if (x ** 2 + 1) % 5 != 0]
　　　
列表推导式的嵌套
语法：
　　[表达式
      for 变量1 in 可迭代对象1 if 真值表达式1
          for 变量2 in 可迭代对象2 if 真值表达式2
              ...
  ]
例如:
   s = "ABC"
   s2 = "123"
   生成如下列表：
   　　['A1', 'A2', 'A3', 'B1', 'B2', ....]
   L　= [x + y for x in s for y in s2]