Python数据类型之列表

1. 序列

   (1).序列是Python中最基本的数据结构。序列中的每一个元素都分配一个数字，代表它在序列中的位置(索引),第一个索引时0，第二个索引是1，以此类推。

   (2).序列中的所有元素都是有编号的，从0开始递增;可以通过编号分别对序列的元素进行访问：在变量后加中括号，在中括号中输入所取元素的编号值。

   (3).序列是一种数据存储方式，用来存储一系列的数据，在内存中，序列就是一块用来存放多个值的连续的内存空间，比如整数系列[10, 20, 30, 40]。

   (4).Python中一切皆对象，在内存中实际是按照a = [10, 20, 30, 40]这种方式存储的。

   (5).在Python中，常用的序列结构有：字符串，列表，元组，字典，集合等。

   (6).Python中所有序列都可以进行一些特殊操作，包括索引,分片,序列相加,乘法,成员资格,长度,最小值和最大值;

   (7).序列中的元素从0开始，从左向右依自然顺序编号递增；也可以从右向左开始索引，最右边的元素索引值为-1，从右向左递减；

   (8).在Python中，从左向右索引称为正数索引，从右向左索引称为负数索引。使用负数索引时，Python会从最后一个元素开始计数，最后一个元素的位置编号是-1。

2. 列表

   列表：用于存储任意数目，任意类型的数据集合。

   列表是内置可变序列，是包含多个元素的有序连续的内存空间。

   列表定义如下：a = [10, 20, 30, 40], 其中，10,20,30,40这些称为：列表a的元素，可以使用索引来获取到

   列表中的元素可以是任意类型的，也可以是列表。列表中包含列表就是嵌套列表。

   列表大小可变，可以根据需要随时增加或缩小。

   字符串和列表都是系列类型，一个字符串是一个字符系列，一个列表是任何元素的序列。

3. 列表的创建

   (1) 列表的创建使用[]来实现，列表元素直接使用逗号(,)分隔开。

   创建一个空列表a：a = []

   (2) 使用list()可以将任何可迭代的数据转化为列表，

   比如：a = list(range(10))

   (3) 使用range()创建整数列表

   range()可以帮助我们非常方便的创建整数列表，语法为：range([start,] end [,step]), 参数说明：

   start参数： 可选，表示起始数字，默认为0；

   end参数： 必填，表示结尾数字；

   step参数：可选，表示递增步长，不写默认步长为1；

   Python3中range()返回的是一个range对象，而不是列表，我们还需要使用list()方法将其转化成列表对象；

   比如：list(range(3, 15, 2))

   (4)结合for循环推导式生成列表，比如：

      a = [x*2 for x in range(5)]   # 生成一个整数列表

      a = [x*3 for x in range(100) if x % 9 == 0]  # 通过if条件过滤生成列表

4. 获取列表元素

   (1) 使用列表元素的下标索引来获取到对应的值

   (2) 通过切片slice操作来获取列表的子列表或修改这个列表，语法：[起始偏移量 start: 终止偏移量 end [: 步长 step]]

       [:] 提取整个列表

       [start:] 从start索引开始到结尾

       [:end] 从头开始到end-1

       [start:end] 从start到end-1

       [start:end:step] 从start提取到end-1，步长是step

       [-start:]  倒数start

       [start::-1] 从start开始提取，步长为负数，逆向提取

       [-start:-end] 倒数第start个到倒数第end-1个

       [::-1]  步长为负数，从右到左反向提取

       切片操作时，起始偏移量和终止偏移量不在[0, 字符串长度-1]这个范围，也不会报错。起始偏移量小于0则会被当做0处理，终止偏移量大于“长度-1”会被当做-1处理。

5. 修改列表

   通过列表的索引取出列表值，然后赋予新值；另外可以使用append()方法为列表添加新值；

   在Python的列表中，不能为一个不存在的位置赋值。一旦初始化了一个列表，就不能再往这个列表中增加元素了。如果需要往列表中增加元素，需要使用列表的append()方法来实现。

   比如：list1 = ['abc', 'def', 'ABC', 'DEF']

   list1[2] = 200   # 修改列表元素

   list1.append("100")  # 增加列表元素

   也可以使用列表的分片来为列表赋值，比如：

   list1[2:2] = list("ghij")

   最终的列表list1 = ['abc', 'def', 'g', 'h','i','j' 'ABC', 'DEF']

6. 删除列表元素

   可以def语句或remove()方法来删除列表元素

   比如：del list1[2]

   也可以使用列表的分片操作来删除元素，比如：

   list1[1:2] = []

7. Python列表操作符

   (1) + 使用加操作符合(+)并两个列表

   (2) * 使用乘操作符号(*)复制列表

   (3) in 判断某个元素是否存在于某个列表, 存在返回True，不存在返回False

   (4) not in 判断某个元素是否不存在于某个列表，不存在返回True，存在返回False

代码示例：

#!/usr/bin/python3
# -*- coding: utf-8 -*-
# author : liuhefei
# Time : 2019/11/9
# desc:  Python数据类型之列表

if __name__ == "__main__":
    # 定义一个空列表
    list1 = []

    # 定义一个整数列表
    list2 = [1, 22, 333, 4444, 55555, 666666]

    # 定义一个字符串列表
    list3 = ['Java', 'Python', 'Html5', 'JavaScript', 'Vue.js']

    # 使用range生成一个整数列表
    list4 = list(range(20, 3))
    print("list3 = ", list3)

    # 结合for循环推导式生成列表
    a = [x * 2 for x in range(5)]  # 生成一个整数列表
    print("列表a = ", a)

    b = [x * 3 for x in range(100) if x % 9 == 0]  # 通过if条件过滤生成列表
    print("列表b = ", b)

    # 访问列表中的元素
    #print("list1[0] = ", list1[0])  # 报错，空列表
    print("list2[2] = ", list2[2])
    print("list3[4] = ", list3[4])

    # 修改列表的元素
    print("list2的第5个元素是：", list2[5])
    list2[5] = 'CSS3'
    print("更新的list2为： ", list2)

    list3[0] = '莫愁前路无知己'
    list3[1] = '天下谁人不识君'
    print("list3 = ", list3)

    # 删除列表元素
    print("list2 = ", list2)
    del list2[5]
    print("删除元素后的list1 = ", list2)

    # 也可以使用列表的分片操作来删除元素，比如：
    list2[1:3] = []
    print("list2 = ", list2)

    # 添加列表元素
    print("list1 = ", list1)
    list1.append("己所不欲")
    list1.append("勿施于人")
    list1.append("沉鱼落雁")
    list1.append("闭月羞花")
    print("添加元素后的list = ", list1)

    # 使用列表的分片来增加元素
    list1[2:2] = list(("一心一意", "二龙戏珠", "三从四德", "四通八达"))
    print("list1 = ", list1)

    # [:] 提取整个列表
    print("b[:] = ", b[:])

    # [start:] 从start索引开始到结尾
    print("b[5:] = ", b[5:])

    # [:end] 从头开始到end-1
    print("b[:25] = ", b[:25])

    # [start:end] 从start到end-1
    print("b[5:30] = ", b[5:30])

    # [start:end:step] 从start提取到end-1，步长是step
    print("b[5:50:3] = ", b[5:50:3])

    # [-start:]  倒数start
    print("b[-5] = ", b[-5])

    # [-start:-end] 倒数第start个到倒数第end-1个
    print("b[-2:-8] = ", b[-2:-8])

    # [::-1]  步长为负数，从右到左反向提取
    print("b[::-1] = ", b[::-1])

    # [start::-1] 从start开始提取，步长为负数，逆向提取
    print("b[3::-1] = ", b[3::-1])

    #  + 使用加操作符合(+)并两个列表
    print("list1 + list2 = ", list1 + list2)
    print("list3 + list4 = ", list3 + list4)

    #  * 使用乘操作符号(*)复制列表
    print("list1*3 = ", list1*3)
    print("list2*2 = ", list2*2)

    #  in 判断某个元素是否存在于某个列表, 存在返回True，不存在返回False
    if 4444 in list2:
        print("4444在列表list2中")
    else:
        print("4444不在列表list2中")

    #  not in 判断某个元素是否不存在于某个列表，不存在返回True，存在返回False
    if 4 not in [1, 2, 3, 4]:
        print("4不存在于列表中")
    else:
        print("4存在于列表中")

    # 定义一个嵌套列表
    lists = [1, 2, 3, 4, [8, 9, 10, 11]]
    print("lists = ", lists)

    list5 = [1, 2, 3, 4, (10, 20, 30, 40)]
    print("list5 = ",list5)

8. 列表函数

（1）. len(list) 获取列表的元素个数

（2）. max(list) 返回列表元素中的最大值

（3）. min(list) 返回列表元素中的最小值

（4）. list(seq) 该方法用于将元组或字符串转化为列表。seq是要转化为列表的元组或字符串。

（5）. list.append(obj) 该方法用于在列表末尾添加新的对象。obj代表需要添加到列表list末尾的对象。append()方法不是简单的返回一个修改过的新列表，而是直接修改原来的列表。

（6）. list.count(obj) 该方法用于统计某个元素在列表中出现的次数,其中obj代表列表中统计的对象。

（7）. list.extend(seq) 该方法用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表），其中seq代表元素列表。

（8）. list.index(obj) 该方法用于从列表中找出某个值第一个匹配项的索引位置，obj代表要查找的对象。

（9）. list.insert(index, obj) 该方法用于将对象插入列表，其中index代表对象obj需要插入的索引位置，obj代表需要插入列表中的对象。

（10）. list.pop([index=-1]) 该方法用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。

    pop()方法是唯一一个既能修改列表又能返回元素怒值(除了None)的列表方法。使用pop()方法可以实现数据结构中的栈

（11）. list.remove(obj) 该方法用于移除列表中某个值的第一个匹配项，obj为类别中要移除的对象。

（12）. list.reverse() 该方法用于反向列表中的元素(逆序)

（13）. list.sort() 该方法用于对原列表进行排序，如果指定参数，就使用参数指定的比较方法进行排序。

    list.sort( key=None, reverse=False) 对原列表进行排序，

    参数说明：key主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。reverse定义排序规则，如果reverse = True 降序， reverse = False 升序（默认）。

（14）. list.clear() 该方法用于清空列表

（15）. list.copy() 该方法用于复制列表

说明：list.extend(seq), list.insert(index, obj), list.remove(obj), list.reverse(), list.sort(), str1.clear()等方法均返回None。

代码示例：

#!/usr/bin/python3
# -*- coding: utf-8 -*-
# author : liuhefei
# Time : 2019/11/17
# desc:  Python列表函数

if __name__ == "__main__":
    num = [1, 8, 0, 3, 6, -1, -9, 100, 7, 2, 1, 2, 3, 100, 8]
    num1 = [10, 20, 30, 40, 50, 60, 70]
    str1 = ['a', 'd', 'f', 'g', 'd', 'b', 'c', 'd']
    str2 = [1, 9, 6, 'A', 'B', 'C', 'a', 'b', 'c']
    str3 = "为了报仇我计划三年"
    str4 = ['我们', '你们', '它们', '他们', '她们']
    # 如果没人欣赏你，那就自己欣赏自己；如果没人祝福你，那就自己祝福自己。
    str5 = ["难过", "别", "如果没人", "别害怕", "自己欣赏自己",
            "欣赏你那就", "那就自己祝福自己", "如果没人祝福你"]
    str6 = ['f', 'b', 'z', 'w', 'a', 'c', 'k']
    tuple = ("假如爱有天意", "雪飞落",
             "风拂面", "雪恋衣裳", "人念人")

    # 1. len(list) 获取列表的元素个数
    print("len(num) = ", len(num))
    print("len(str1) = ", len(str1))
    print("len(str2) = ", len(str2))

    # 2. max(list) 返回列表元素中的最大值
    print("max(num) = ", max(num))
    print("max(str1) = ", max(str1))
    # print("max(str2) = ", max(str2))  #报错，类型不一致

    # 3. min(list) 返回列表元素中的最小值
    print("min(num) = ", min(num))
    print("min(str1) = ", min(str1))

    # 4. list(seq) 该方法用于将元组或字符串转化为列表。
    # seq是要转化为列表的元组或字符串。
    print("list(str3) = ", list(str3))
    print("list(tuple) = ", list(tuple))

    # 5. list.append(obj) 该方法用于在列表末尾添加新的对象。
    # obj代表需要添加到列表list末尾的对象。
    # append()方法不是简单的返回一个修改过的新列表，而是直接修改原来的列表。
    num.append(1000)
    num.append(10000)
    print("num = ", num)

    str1.append('h')
    str1.append('i')
    str1.append('j')
    print("str1 = ", str1)

    # 6. list.count(obj) 该方法用于统计某个元素在列表中出现的次数,
    # 其中obj代表列表中统计的对象。
    print("num.count(100) = ", num.count(100))
    print("str1.count('a') = ", str1.count('a'))
    print("str2.count('a') = ", str2.count('a'))

    # 7. list.extend(seq) 该方法用于在列表末尾一次性
    # 追加另一个序列中的多个值（用新列表扩展原来的列表），
    # 其中seq代表元素列表。
    print("str1.extend(str2) = ", str1.extend(str2))
    print("str1 = ", str1)
    print("num.extend([100, 200, 300]) = ",
          num.extend([100, 200, 300]))
    print("num = ", num)

    # 8. list.index(obj) 该方法用于从列表中找出某个值
    # 第一个匹配项的索引位置，obj代表要查找的对象。
    print("num.index(100) = ", num.index(100))
    print("str1.index('d') = ", str1.index('d'))

    # 9. list.insert(index, obj) 该方法用于将对象插入列表，
    # 其中index代表对象obj需要插入的索引位置，
    # obj代表需要插入列表中的对象。该方法不会返回值。
    print("num.insert(5, 10000) = ", num.insert(5, 10000))
    print("num = ", num)

    print("str1.insert(2, 'ABCD') = ", str1.insert(2, "ABCD"))
    print("str1 = ", str1)

    print("str2.insert(4, 'abcd') = ", str2.insert(4, 'abcd'))
    print("str2 = ", str2)

    # 10. list.pop([index=-1]) 该方法用于移除列表中的一个元素
    # （默认最后一个元素），并且返回该元素的值。
    #  pop()方法是唯一一个既能修改列表又能返回元素怒值(除了None)的
    #  列表方法。使用pop()方法可以实现数据结构中的栈
    print("num = ", num)
    print("num.pop() = ", num.pop())
    print("num.pop(5) = ", num.pop(5))
    print("num.pop(-4) = ", num.pop(-4))

    # 11. list.remove(obj) 该方法用于移除列表中某个值的
    # 第一个匹配项，obj为类别中要移除的对象。
    print("str1.remove('a') = ", str1.remove('a'))
    print("str1 = ", str1)

    print("str4.remove('它们') = ", str4.remove('它们'))
    print("str4 = ", str4)

    # 12. list.reverse() 该方法用于反向列表中的元素(逆序)
    print("num1 = ", num1)
    print("num1.reverse() = ", num1.reverse())  # 不返回值
    print("num1 = ", num1)

    print("str4 = ", str4)
    print("str3.reverse() = ", str4.reverse())  # 不返回值
    print("str4 = ", str4)

    # 13. list.sort() 该方法用于对原列表进行排序，
    # 如果指定参数，就使用参数指定的比较方法进行排序。
    # list.sort( key=None, reverse=False) 对原列表进行排序，
    # 参数说明：key主要是用来进行比较的元素，只有一个参数，
    # 具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
    # reverse定义排序规则，如果reverse = True 降序， reverse = False 升序（默认）。
    # sort()方法不返回值
    print("num.sort() = ", num.sort())
    print("num = ", num)

    print("str5.sort(key=len, reverse=True")
    print("str5 = ", str5)

    print('str6.sort() = ', str6.sort())
    print("str6 = ", str6)

    print("str6.sort(key=max) = ", str6.sort(key=max))
    print("str6 = ", str6)

    # 14. list.copy() 该方法用于复制列表
    print("newStr1 = ", str1.copy())
    print("newNum = ", num.copy())

    # 15. list.clear() 该方法用于清空列表
    print("str1.clear() = ", str1.clear())
    print("str1 = ", str1)

    print("str2.clear() = ", str2.clear())
    print("str2 = ", str2)

来源：gzh：学虽易学好难 （stydy3344)

结束语：让坚持成为一种习惯！