06. Python语言的核心编程 · 第六章 Python的列表基础操作汇总

1. 序列（sequence）

1.1 基本概念

  序列是 Python语言 中最基本的一种数据结构。数据结构是指计算机中数据存储的方式，序列用于 保存一组有序的数据 。所有的数据在序列当中都有一个 唯一的位置（索引） ，并且序列中的数据会按照添加的顺序来分配索引。
  Python语言 有6个序列的内置类型，但最常见的是 列表 和 元组 。
  序列 都可以进行的操作包括 索引，切片，加，乘，检查成员。
  此外，Python语言 已经内置确定序列的长度以及确定最大和最小的元素的方法。

1.2 序列的分类

  可变序列（序列中的元素可以改变）：例如 列表（list）、字典(dict) …
  不可变序列（序列中的元素不能改变）：例如 字符串（str）、元组（tuple）…
  

2. 列表(list)

  列表 是最常用的 Python语言 的数据类型，它可以作为一个方括号内的逗号分隔值出现。
  列表 的数据项 不需要 具有相同的类型。
  列表 是 Python语言 中的一个 对象 。
  列表的作用：
   1）列表中可以保存多个有序的数据；
   2）列表是用来存储 对象的对象。

2.1 列表的使用

  列表的创建：
    通过 xxx = [ ] 来创建一个空列表。

  参考案例：

list1 = ['Google', 'Runoob', 1997, 2000];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"];

2.2 切片（实操、面试 必备的基础技能）

  切片是指从现有列表中获得一个子列表。
  通过切片来获取指定的元素。

  语法: 列表名[起始索引 ：结束索引 ：步长]

  Python的列表截取切片与字符串操作类型，如下所示：

L=['Google', 'Runoob', 'Taobao']

  Python的列表操作：

  具体代码：

>>>L=['Google', 'Runoob', 'Taobao']
>>> L[2]
'Taobao'
>>> L[-2]
'Runoob'
>>> L[1:]
['Runoob', 'Taobao']
>>>

  列表还支持拼接操作：

>>>squares = [1, 4, 9, 16, 25]
>>> squares += [36, 49, 64, 81, 100]
>>> squares
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

  我们看一个稍微复杂点的参考案例：

hero = ['蜘蛛侠','钢铁侠','绿巨人','黑寡妇','美国队长','蚁人']
# 做切片操作时，每次获取的都是初始列表，不是切过后的列表，不会影响原始列表

# 起始位置和结束位置的索引可以不写
print(hero)
# ['蜘蛛侠', '钢铁侠', '绿巨人', '黑寡妇', '美国队长', '蚁人']

# 切片时指定起始位置和结束位置的索引后获取的结果
print(hero[1:3])
# ['钢铁侠', '绿巨人']

# 如果省略结束位置，则会从当前位置开始一直截取到最后；
print(hero[1:])
# ['钢铁侠', '绿巨人', '黑寡妇', '美国队长', '蚁人']

# 如果省略开始位置，则会从第一个元素开始截取到结束位置的元素，但不包含结束位置的元素；
print(hero[:3])
# ['蜘蛛侠', '钢铁侠', '绿巨人']

# 如果省略开始和结束的位置，则会从第一个元素截取到最后一个元素
print(hero[:])
# ['蜘蛛侠', '钢铁侠', '绿巨人', '黑寡妇', '美国队长', '蚁人']

# 步长：表示每次获取元素的间隔  默认为1  可以省略
print(hero[::2])
# ['蜘蛛侠', '绿巨人', '美国队长']

# 步长不能为 0  
print(hero[::0])
# ValueError: slice step cannot be zero

# 步长可以为负数，
print(hero[::-1])
# ['蚁人', '美国队长', '黑寡妇', '绿巨人', '钢铁侠', '蜘蛛侠']

  通过切片获取元素时，会包括起始位置的元素，不会包括结束位置的元素；
  起始位置 和 结束位置 的索引可以不写；
  如果省略结束位置，则会 从当前的位置开始 一直截取到最后；
  如果省略开始位置，则会从第一个元素截取到结束的元素，但是不包括结束的元素；
  如果开始位置和结束位置都省略, 则会从第一个元素开始截取到最后一个元素。
  步长 表示每次获取元素的间隔，默认是1(可以省略不写)；
  步长 不能是0,但可以是是 负数（从后向前的获取列表中的元素）。
  

3. 通用操作

  +  和  *
  +  可以将 两个列表 拼接成 一个列表；
  *   可以将 列表内的元素重复指定的次数 (注意：2个列表不能够做乘法，要和整数做乘法运算。)

# + 表示  可以将两个列表拼接成一个列表
lst = [1,2,3] + [4,5,6]
print(lst)
# [1, 2, 3, 4, 5, 6]

# * 表示将列表中的元素指定重复次数
lst = [1,2,3] * 2
print(lst)
# [1, 2, 3, 1, 2, 3]

# 列表和列表不能相乘   
lst = [1,2,3] * [4,5,6]
print(lst)
# TypeError: can't multiply sequence by non-int of type 'list'

  in  和  not in
  in   用来检查指定元素是否在列表当中；
  not in  用来检查指定元素是否不在列表当中。

hero = ['蜘蛛侠','钢铁侠','绿巨人','黑寡妇','美国队长','蚁人','钢铁侠','钢铁侠','钢铁侠','钢铁侠']

print('雷声' in hero)
# False

print('雷声' not in hero)
# True

  len() 获取列表中元素的个数

hero = ['蜘蛛侠','钢铁侠','绿巨人','黑寡妇','美国队长','蚁人','钢铁侠','钢铁侠','钢铁侠','钢铁侠']
print(len(hero))
# 10

  对 Python列表脚本操作符简单汇总表：

  max()   获取列表中最大值
  min()  获取列表中最小值

lstt = [11,2,5,999,8,3333]

print(max(lstt))
# 3333

print(min(lstt))
# 11

  list.index( x[, start[, end]] )
  第一个参数 获取在列表中指定的元素
  第二个参数 表示查找的起始位置
  第三个参数 表示查找的结束位置

hero = ['蜘蛛侠','钢铁侠','绿巨人','黑寡妇','美国队长','蚁人','钢铁侠','钢铁侠','钢铁侠','钢铁侠']

print(hero.index('钢铁侠',4,9))
# 6

  list.count(x) 统计指定元素在列表中出现的个数

hero = ['蜘蛛侠','钢铁侠','绿巨人','黑寡妇','美国队长','蚁人','钢铁侠','钢铁侠','钢铁侠','钢铁侠']

print(hero.count('钢铁侠'))
# 5

print(hero.count('蝙蝠侠'))
# 0

  

4. 嵌套列表

  使用嵌套列表即在列表里创建其它列表，例如：

>>>a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

  

5. 修改列表

  通过 切片 来修改(起始就是给切片的内容重新赋值，但是赋值的内容必须是一个序列)

  当设置了步长时,序列中元素的个数必须和切片中元素的个数保持一致

hero = ['蜘蛛侠','钢铁侠','绿巨人','黑寡妇']

hero[6] = 'b'  
# IndexError: list assignment index out of range

  通过切片来删除列表中的元素
  del list[元素索引] ：删除列表里元素索引指向的元素。

hero = ['蜘蛛侠','钢铁侠','绿巨人','黑寡妇']
print ("修改前", hero)
# 修改前 ['蜘蛛侠', '钢铁侠', '绿巨人', '黑寡妇']

del hero[2]
print ("删除第三个元素", hero)
# 删除第三个元素 ['蜘蛛侠', '钢铁侠', '黑寡妇']

  list(seq) 方法用于将元组或字符串转换为列表。

aTuple = (123, 'Google', 'Runoob', 'Taobao')
list1 = list(aTuple)
print ("列表元素 : ", list1)
# 列表元素 :  [123, 'Google', 'Runoob', 'Taobao']

str="Hello World"
list2=list(str)
print ("列表元素 : ", list2)
# 列表元素 :  ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']

  

6. 对列表进行 增·删·改·查 的几种方法

6.1 增

  1） append(obj) ：向列表的最后添加一个元素；

hero = ['蜘蛛侠','钢铁侠','绿巨人','黑寡妇']
print('修改前',hero)
# 修改前 ['蜘蛛侠', '钢铁侠', '绿巨人', '黑寡妇']

hero.append('灭霸')
print('修改后',hero)
# 修改后 ['蜘蛛侠', '钢铁侠', '绿巨人', '黑寡妇', '灭霸']

  2） insert(arg1,arg2) ：向列表指定位置插入一个元素；参数1:要插入的位置，参数2:要插入的元素；新插入的元素 不会替换掉 原位置上的元素，而是将原位置上的元素 向后的挤 了一个位置。

hero = ['蜘蛛侠','钢铁侠','绿巨人','黑寡妇']
print('修改前',hero)
# 修改前 ['蜘蛛侠', '钢铁侠', '绿巨人', '黑寡妇']

hero.insert(2,'灭霸')
print('修改后',hero)
# 修改后 ['蜘蛛侠', '钢铁侠', '灭霸', '绿巨人', '黑寡妇']

  3） extend(seq) ：使用一个新的序列来 扩展 当前序列(它会将该序列的中元素添加到列表中) 参数需要传递一个序列。
  参数 seq ：元素列表，可以是列表、元组、集合、字典，若为字典,则仅会将键(key)作为元素依次添加至原列表的末尾。

list1 = ['Google', 'Runoob', 'CSDN', 'Taobao']
list2=list(range(5)) # 创建 0-4 的列表
list1.extend(list2)  # 扩展列表
print ("扩展后的列表：", list1)
# 扩展后的列表： ['Google', 'Runoob', 'CSDN', 'Taobao', 0, 1, 2, 3, 4]

6.2 删

  1） del list[元素索引] ：删除列表里元素索引指向的元素。

hero = ['蜘蛛侠','钢铁侠','绿巨人','黑寡妇']
print ("修改前", hero)
# 修改前 ['蜘蛛侠', '钢铁侠', '绿巨人', '黑寡妇']

del hero[2]
print ("删除第三个元素", hero)
# 删除第三个元素 ['蜘蛛侠', '钢铁侠', '黑寡妇']

  2） pop() ：根据索引删除指定元素，并返回完成删除后的序列 (在使用 pop()函数 时没有添加指定索引，默认删除最后一个元素)；

hero = ['蜘蛛侠','钢铁侠','绿巨人','黑寡妇']
print ("修改前", hero)
# 修改前 ['蜘蛛侠', '钢铁侠', '绿巨人', '黑寡妇']

hero.pop()
print ("列表现在为 : ", hero)
# 列表现在为 :  ['蜘蛛侠','钢铁侠','绿巨人']

hero.pop(1)
print ("列表现在为 : ", hero)
# 列表现在为 :  ['蜘蛛侠', '绿巨人']

  3） remove() ：删除 指定元素 (如果与这 指定元素 相同值的元素有多个，只会删除列表里的第一个)；

hero = ['蜘蛛侠','钢铁侠','绿巨人','绿巨人','黑寡妇','钢铁侠','钢铁侠']
print ("修改前", hero)
# 修改前 ['蜘蛛侠','钢铁侠','绿巨人','绿巨人','黑寡妇','钢铁侠','钢铁侠']

hero.remove('蜘蛛侠')
print ("列表现在为 : ", hero)
# 列表现在为 :  ['钢铁侠', '绿巨人', '绿巨人', '黑寡妇', '钢铁侠', '钢铁侠']

hero.remove('钢铁侠')
print ("列表现在为 : ", hero)
# 列表现在为 :  ['绿巨人', '绿巨人', '黑寡妇', '钢铁侠', '钢铁侠']

  4） clear() ：函数用于 清空列表，类似于上面的 del a[:]。

hero = ['蜘蛛侠','钢铁侠','绿巨人','黑寡妇']
print('修改前',hero)
# 修改前 ['蜘蛛侠', '钢铁侠', '绿巨人', '黑寡妇']

hero.clear()
print ("列表清空后 : ", hero)
# 列表清空后 :  []

6.3 改

  1） reverse() ：翻转列表

hero = ['蜘蛛侠','钢铁侠','绿巨人','黑寡妇']
print('修改前',hero)
# 修改前 ['蜘蛛侠', '钢铁侠', '绿巨人', '黑寡妇']

hero.reverse()
print ("列表现在为 : ", hero)
# 列表现在为 :  ['黑寡妇', '绿巨人', '钢铁侠', '蜘蛛侠']

  2） sort(key=None,reverse=False) ：用来对列表中的元素进行排序。reverse：True反序；False 正序

hero = ['蜘蛛侠','钢铁侠','绿巨人','黑寡妇']
print('修改前',hero)
# 修改前 ['蜘蛛侠', '钢铁侠', '绿巨人', '黑寡妇']

hero.sort()
print ("列表现在为 : ",hero)
# 列表现在为 :  ['绿巨人', '蜘蛛侠', '钢铁侠', '黑寡妇']

#-----------------------------------------------------------

# 列表
vowels = ['e', 'a', 'u', 'o', 'i']
 
# 降序
vowels.sort(reverse=True)
 
# 输出结果
print ( '降序输出:', vowels )
# 降序输出: ['u', 'o', 'i', 'e', 'a']

#-----------------------------------------------------------

# 获取列表的第二个元素
def takeSecond(elem):
    return elem[1]
 
# 列表
random = [(2, 2), (3, 4), (4, 1), (1, 3)]
 
# 指定第二个元素排序
random.sort(key=takeSecond)
 
# 输出类别
print ('新排序列表：', random)
# 新排序列表：[(4, 1), (2, 2), (1, 3), (3, 4)]

  3） copy() 函数用于 复制列表，类似于 a[:]。

hero = ['蜘蛛侠','钢铁侠','绿巨人','黑寡妇']
hero2 = hero.copy()
print ("hero2 列表: ", hero2)
# hero2 列表:  ['蜘蛛侠', '钢铁侠', '绿巨人', '黑寡妇']

hero.append('灭霸')
print ("hero 列表: ", hero)
# hero 列表:  ['蜘蛛侠', '钢铁侠', '绿巨人', '黑寡妇', '灭霸']
print ("hero2 列表: ", hero2)
# hero2 列表:  ['蜘蛛侠', '钢铁侠', '绿巨人', '黑寡妇']

  

7. 遍历列表

7.1 for循环

  通过 for循环 来遍历列表

for循环 语法
for 变量 in 序列(遍历的规则):
    代码块

  参考案例

heros = ['蜘蛛侠','钢铁侠','绿巨人','黑寡妇','美国队长','蚁人','钢铁侠','钢铁侠','钢铁侠','灭霸','钢铁侠']
for hero in heros:
    if hero == '灭霸':
        print('灭霸--最后的BOSS')
        break
    print("登场英雄：",hero)
else:
    print("没有循环数据!")
print("完成循环!")
# 登场英雄： 蜘蛛侠
# 登场英雄： 钢铁侠
# 登场英雄： 绿巨人
# 登场英雄： 黑寡妇
# 登场英雄： 美国队长
# 登场英雄： 蚁人
# 登场英雄： 钢铁侠
# 登场英雄： 钢铁侠
# 登场英雄： 钢铁侠
# 灭霸--最后的BOSS
# 完成循环!

  注意: for循环的代码块会执行多次，序列中有几个元素就会执行几次。每执行一次就会将序列中的一个元素赋值给变量，所以我们可以通过变量来获取列表中的元素。

7.2 range(start, stop[, step])

  参数说明：
   start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;

>>>for i in range(5):
...     print(i)
...     
0
1
2
3
4

   stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5

>>>for i in range(5,9) :
...     print(i)
...     
5
6
7
8
>>>

   step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)

>>>for i in range(0, 10, 3) :
...     print(i)  
...     
0
3
6
9
>>>

   start、stop、step 可以为负数

>>>for i in range(-10, -100, -30) :
...     print(i)  
...     
-10
-40
-70
>>>

  结合 range() 和 len() 函数以遍历一个序列的索引，如下案例所示：

hero = ['蜘蛛侠','钢铁侠','绿巨人','黑寡妇']
>>> for i in range(len(hero)):
...     print(i, hero[i]) 
...    
0 蜘蛛侠
1 钢铁侠
2 绿巨人
3 黑寡妇

  还可以使用 range() 函数来创建一个列表：

>>>list(range(5))
[0, 1, 2, 3, 4]
>>>

  
  

总结小便条

本篇文章主要讲了以下几点内容：

1. 序列是 Python语言 中最基本的一种数据结构。

2. 序列分为：可变序列（序列中的元素可以改变） 和 不可变序列（序列中的元素不能改变）
   2.1 可变序列 ：例如 列表（list）、字典(dict) …
   2.2.不可变序列 ：例如 字符串（str）、元组（tuple）…

3. 我们今天除了介绍 Python语言 中的序列，更重要的讲的是列表。那什么是列表？
   答：列表 是最常用的 Python语言 的数据类型，它可以作为一个方括号内的逗号分隔值的形式出现。这个样子： xxx = [ ]

4. 即然知道什么是列表了，那我们要怎么 使用它 ？
   答：第一个，毫无疑问：切片。（这是 实操、面试 必备的基础技能）
     列表切片的语法: 列表名[起始索引 ：结束索引 ：步长]
     查看切出来的子元素的方式：print(列表名[起始索引 ：结束索引 ：步长])

     第二个，作为 “魔鬼” 的代名词的列表怎么会只有这一种简单的操作。
         多列表的合并 ( lst = [1,2,3] + [4,5,6] )
         列表中的元素多次的重复 ( lst = [1,2,3] * 2 )
         判断元素x是否在列表中 ( print(‘x’ in/not in lst) )
         列表中有多少元素 ( print(len(lst)) )
         获取列表中 最大( max(lst) )/小( min(lst) )值
         统计指定元素在列表中的指定区间出现的个数( list.index(‘x’,起始位置,结束位置) )
         统计指定元素在列表中出现的个数( list.count(x) )

     第三个，列表的 增·删·改·查
       我们单独的拎出了两大块，分别在 第4块 讲解了 列表的特殊“增”–嵌套列表 和 第5块 列表的特殊“删·改”–修改列表。
       第4块 嵌套列表：将多个列表合并进一个大(父)列表里。
       第5块 修改列表：通过“切片”的步长和指向修改列表里指定的值。
       第6块 增：append(obj) ：向列表的最后添加一个元素；
            insert(arg1,arg2) ：向列表指定位置插入一个元素，新插入的元素 不会替换掉 原位置上的元素；
            extend(seq) ：使用一个新的序列来 扩展 当前序列；

          删：del list[元素索引] ：删除列表里元素索引指向的元素；
            pop() ：根据索引删除指定元素，并返回完成删除后的序列 (在使用 pop()函数 时没有添加指定索引，默认删除最后一个元素)；
            remove() ：删除 指定元素 (如果与这 指定元素 相同值的元素有多个，只会删除列表里的第一个)；
            clear() ：函数用于 清空列表，类似于上面的 del a[:]；

          改：reverse() ：翻转列表；
            sort(key=None,reverse=False) ：用来对列表中的元素进行排序；
            copy() ：函数用于 复制列表，类似于 a[:] ；

          查：最简单，四个字 切片操作。

     第四个，列表的循环遍历 for 循环：

       for循环 的代码块会 执行多次，序列中有几个元素就会执行几次。每执行一次就会将序列中的一个元素赋值给变量一次，所以我们可以通过变量来获取列表中的元素。  具体怎么个 for循环 看案例里的源代码。

       在用 for 循环遍历列表时，使用 range()函数 和 len()函数 这两个函数来辅助遍历，打印出来的数据会更加的简介明了，阅读时会更加的方便。  具体怎么使用，回顾上面案例里的源代码。

 本章回顾暂时就到这了，如果还有点晕，那就去完成作业吧。拜拜~

  
  

课程作业

  1. 将本篇博客所讲的所有内容自己练习多编；
  2. 现在有 a = [1,2,3,4,5,6] 不通过函数的形式实现列表的反转([6,5,4,3,2,1]) 并写出推导过程。
  3. 实现列表推导式 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
  4. 通过 for循环 的循环嵌套实现 [9,6,7,3,2,1,5,8] 数列的排序。(面试必考：冒泡循环。最基础的循环遍历排序)
  5. 现有两个列表 i_1 = [11, 22, 33] 和 i_2 = [22, 33, 44]，获取两个列表当中相同的元素。

  
  
  
  

参考答案

# 作业 2
# 本题，与其说是计算机面试考题，不如说是是一道对语文·阅读理解的考题；本题的核心考点是：面试者对 列表的“切片操作” 的理解。

a = [1,2,3,4,5,6]

# 考点 列表当中的切片

# 起始位置和结束位置的索引可以不写
# 如果我省略结束位置，则会从当前的开始位置一直截取到最后；
print(a[1:])
# [2, 3, 4, 5, 6]

# 如果省略开始位置，则会从第一个元素截取到结束位置的元素，但是不包括结束的元素；
print(a[:3])
# [1, 2, 3]

#  如果开始位置和结束位置都省略，则会从第一个元素截取到最后一个元素。
print(a[:])
# [1,2,3,4,5,6]

# 语法  列表[起始:结束:步长]
print(a[0:5])
# [1, 2, 3, 4, 5]

print(a[0:5:1])
# [1, 2, 3, 4, 5]

print(a[::2])
# [1, 3, 5]

# 如果步长为负从右往左取值
print(a[4:1:-1])
# [5, 4, 3]

# 最后，如果想不通过函数的形式实现列表 a = [1,2,3,4,5,6] 的反转([6,5,4,3,2,1])。
print(a[::-1])
# [6, 5, 4, 3, 2, 1]

#-----------------------------------------------------------------------------------

# 3. 实现列表推导式 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
i = [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

print([i for i in range(10)])
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

print([i*i for i in range(10)])
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

#-----------------------------------------------------------------------------------

# 4. 通过 for循环 的循环嵌套实现 [9,6,7,3,2,1,5,8] 数列的排序。

# 对列表实现 [9,6,7,3,2,1,5,8] 数列的排序最简单的方法当然是 函数 i.sort()。
# i = [9,6,7,3,2,1,5,8]
# i.sort()
# print(i)
# 但本题的考点表达是：通过 for循环 的循环嵌套，通过 “冒泡排序” 的方式实现 [9,6,7,3,2,1,5,8] 数列的排序。所以：

def fun(arr):
    n = len(arr)

    # 遍历所有数组元素
    for a in range(n):
    	# print(a)

        # Last a elements are already in place
        for b in range(0, n-a-1):
        	# print(b,end='')
            if arr[b] > arr[b + 1]:
                arr[b], arr[b + 1] = arr[b + 1], arr[b]
                # print(arr[b], end='')

arr = [9,6,7,3,2,1,5,8]

fun(arr)

print(arr)
print("排序后的数组:")
for a in range(len(arr)):
    print("%d" % arr[a])
# 输出结果你自己去测试吧。

#-----------------------------------------------------------------------------------

# 5. 现有两个列表 i_1 = [11, 22, 33]  和  i_2 = [22, 33, 44]，获取两个列表当中相同的元素。

i1 = [11, 22, 33]
i2 = [22, 33, 44]

# 方案 1.

for l1 in i1:
    for l2 in i2:
        if l1 == l2:
            print(l1)



# 方案 2.

for l1 in i1:
    if l1 in i2:
        print(l1)