python数据类型 列表 list(有序)

                        列表：list

定义：
    列表是由一系列元素组成的， 元素与元素之间可能没有任何的的关联关系，
    但他们之间有先后顺序关系
    列表是一种容器
    列表是一种序列
    列表是可以被改变的序列

列表是可变的
可以存放任意
列表是一种容器：
列表是一种序列：
是　有序的可变的容器

可变的有
list, dictionnary  set(集合)　byte

python 中的序列：
   字符串　    str
   列表　      list
   元组　　     tuple
   字节串　     bytes
   字节数组　　  bytearray



创建空列表的字面值：

list1 = []　　　＃Ｌ　绑定空列表


创建非空列表的字面值：
　Ｌ = [1, 2, 3, 4]
 L = ['beijing','shanghai', 'shenzhen']
 L = [1, 'two', 3.3, '四']
 Ｌ= [ 1, 2, [3.1, 3.2, 3.3]]


Python3中常用的列表方法（method)

见:help(list)
方法  意义
L.index(v [, begin[, end]]) 返回对应元素的索引下标, begin为开始索引，end为结束索引,当 value 不存在时触发ValueError错误

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])  删除索引对应的元素，如果不加索引，默认删除最后元素，同时返回删除元素的引用关系


示例：

>>> list("hello")
['h', 'e', 'l', 'l', 'o']
>>> list(range(1,10))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

列表运算：
　+ 　+= 　* 　*=

＋　用于拼接列表
　x = [1,2,3]
 y = [4,5,6]
 z = x + y #z = [1, 2, 3, 4, 5, 6]

+= 用原列表与右侧列表拼接，　并用变量绑定列表
 　
  x = [1, 2, 3]
  x += [4, 5, 6]   # x = [1, 2, 3, 4, 5, 6]


* 生成重复的列表
　　
　 x = [1, 2 ] * 3  # x = [1, 2, 1, 2, 1, 2]
  y = 3 * [5, 6]   # y = [5, 6, 5, 6, 5, 6]

*= 生成重复的列表，　并给原变量赋值
　　
 　　x = [3, 4]
   x *= 2   #[3, 4, 3, 4]
   y = 3
   y *= [6, 7]  #[7, 8, 7, 8, 7,8]
   y * = x  等同于y  = y * x.

列表的比较运算：
　< <= > >= == !=

　示例：
　[1, 2, 3 ] <[1, 2, 4 ] 　　#True
   [1, 3]  >   [1,2, 4] 　　　　#True
   [5] <       [5, 0]　　　　　　　#True
   ['ABC','123'] > ['abc','456'] #False

   [1, 'two'] > ['two', 1] TypeError　int不能和str比较

列表的in / not in 运算符：
    in 判断一个对象是否存在于容器内， 如果存在就返回True 否则
    就会返回 False
    用法同字符串的in相同

　　（字符串中放的都是UNICODE值
语法：　

   数据对象 in 容器

 示例；
     L = [ 1, 'Two', 3.3, '四']
     1   in L  #True
     2   in L  #True
     3.3 in L  #True
     "4"　not in L  #True

列表的索引和切片操作：

    语法：
    　　　列表[整数表达式]
    用法：
    　　　取值时，　等同于字符串的索引操作
    　　　索引分为正向索引和反向索引，　规则与字符串索引规则完全相同
    　　
support(支持)　　assignment(赋值)　  assignment(赋值)
support(支持)

列表支持索引赋值：
    
    列表是可变的序列，可以通过索引赋值改变列表中的元素

示例：
 　 Ｌ　= [1, 2, 3, 4]
   L [2] = 3.3  #将第三个元素改为3.3
                   

列表是可以索引的　正向索引和反向索引[-1] [-2]
列表的切片：
　　　　　语法：
　　　　　　
    列表[:]                   
    列表[::]
    列表的切片取值时，　返回一个列表，　规则等同于字符串切片规则

列表的切片赋值：  切片是就是原来的列表截取下来，建一个新的列表d
　　　　　　　　作用：
　　　
        　　可以改变原列表的排序，可以插入和修改数据
        　　可以用切片改变列表的对应元素的值
    　　　　语法：
    　　　　　　　列表[切片]　＝　可迭代对象
    　　　　　注：　赋值运算符的右侧必须是一个可迭代对象

    　　　　示例：
    　　　　　Ｌ= [2. 3. 4]
         L[0:1] = [1.1, 2.2]   # [1.1, 2.2, 3, 4]
         

         l = [2, 3, 4]
         l[1:] = [3.3, 4.4, 5.5]  # [2, 3.3, 4.4, 5.5]


         l = [2, 3, 4]
         l[:] = [0, 1]

         ＃实现中间插入
         l = [2, 4]
         l[1:1] = [3] # l = [2, 3, 4]
         l[1:1] = [3.3, 4.4] = [2, 3.3, 4.4, 4]

         #实现在前面插入[0, 1]
         l = [2, 3, 4] #实现在前面插入[0, 1]
         l[0:0] = [0, 1]

         l = [2, 3, 4] #实现在后面插入[5, 6]
         l = [3:3] = [5, 6]  #[2, 3, 4, 5, 6]
         l = [-1:-1] = [5, 6]
　
　　　　　　　　　＃用range函数生成的可迭代对象赋值
         l = [1, 4]
         ｌ =[1:1] = range(2, 4)
          l =[2, 3, 4]
          l[1:2] = "ABCD" ＃“ABCD"　也是可迭代对象

    　切片的注意事项：
    　　　　对于步长不等于１的切片赋值，　赋值运算符右侧的可迭代对象
    　　　　提供的元素个数一定要等于切片切出的段数

    　　例：

        l = [1, 2, 3, 4, 5, 6]
        L = [::2] = "ABC" 对的
        ＃　以下切出三段，　但给出５个元素填充是错的
        L = [::2] = "ABCDE"


del语句　　用于删除列表中的元素
　　语法：　 （　删除列表中的变量　）
　　　　del 　序列[整数表达式]
    del 　序列[切片]

　　示例：
　　Ｌ = [1, 2, 3, 4, 5, 6]
  del l[-1]    ＃删除最后一个
  del l[0]     #删除第１个
  del l[::2]   #删除1, 3, 6



python中常用于序列的函数：
　  
len(seq) 返回容器的元素的个数
max()    返回序列中的最大值元素
min(x)    返回序列中的最小值元素
sum()    返回序列中所有元素的和(元素必须是数值类型)
any(x)　　　真值测试，　如果容器内其中一个值为True则返回True则返回False
all(x)　　　真值测试， 容器内所有元素的布尔值都为True 才返回True






L.copy()    复制此列表（只复制一层，不会复制深层对象)
l = [1, 2, 3]
l2 = l.copy()
l2.clear()
l2为空了　
1 没有变

列表推导式 list comprehension

列表推导式是用可迭代对象依次生成带有多个元素的列表的表达式

作用：
   用简易方法生成列表

语法：
   [表达式 for 变量 in 可迭代对象]

   或

   [表达式 for 变量 in 可迭代对象 if 真值表达式]



问题：
   如何生成下列列表
   [1, 4, 9, 16, 25 ..... 81]

   for x in range(1, 10):
    l.apped(x)

#用列表推导式生成：
 
L = [x**2 for x in range(1, 10)]


示例:
  生成[1, 9, 16, 25, 36......81] 列表，跳过所有的偶数

[x **2 for x in range(1, 10) if x % 2 == 1]