Python3.*(第十三课——使用列表)

前一课主要是写的一些自己学习的列表、元组的一些公共的方法。现在这节课我们来学习列表的使用。

元组支持的操作，列表基本上都支持；列表支持对元素的修改，而元组则不支持。如果程序不需要修改列表所包含的元素，那么使用元组。

创建列表

       内置的list（）函数来创建列表， list（）函数可用于将元组、区间（range）等对象转

       换为列表。

              例如：

a_tuple = ('crazyit', 20, -1.2)
# 将元组转换成列表
a_list = list(a_tuple)
print(a_list)
# 使用range()函数创建区间（range）对象
a_range = range(1, 5)
print(a_range) # range(1, 5)
# 将区间转换成列表
b_list = list(a_range)
print(b_list) # [1, 2, 3, 4]
# 创建区间时还指定步长
c_list = list(range(4, 20, 3))
print(c_list) # [4, 7, 10, 13, 16, 19]

Python2.x提供了一个xrange()函数和3.x的range()函数基本相同。2.x提供了range()函数，但是返回的是列表对象。

Python 也提供了一个tuple()函数， 该函数可用于将列表、区间（range）等对象转换为元组

a_list = ['crazyit', 20, -1.2]
# 将列表转换成元组
a_tuple = tuple(a_list)
print(a_tuple)
# 使用range()函数创建区间（range）对象
a_range = range(1, 5)
print(a_range) # range(1, 5)
# 将区间转换成元组
b_tuple = tuple(a_range)
print(b_tuple) # (1, 2, 3, 4)
# 创建区间时还指定步长
c_tuple = tuple(range(4, 20, 3))
print(c_tuple) # (4, 7, 10, 13, 16, 19)

增加列表元素

       列表的append（）方法：

              参数追加到列表的最后面，append （）方法既可接收单个值，也可接收元组、列

              表，该方法只是把元组、列表当成单个元素， 这样就会形成在列表中嵌套列表、

              嵌套元组的情形。

                     例如：

a_list = ['crazyit', 20, -2]
# 追加元素
a_list.append('fkit')
print(a_list) # ['crazyit', 20, -2, 'fkit']
a_tuple = (3.4, 5.6)
# 追加元组，元组被当成一个元素
a_list.append(a_tuple)
print(a_list) # ['crazyit', 20, -2, 'fkit', (3.4, 5.6)]
# 追加列表，列表被当成一个元素
a_list.append(['a', 'b'])
print(a_list) # ['crazyit', 20, -2, 'fkit', (3.4, 5.6), ['a', 'b']]

       列表的extend（）方法：

              追加列表中的元素，追加的内容不被当成一个整体。

                     例如：

b_list = ['a', 30]
# 追加元组中的所有元素
b_list.extend((-2, 3.1))
print(b_list) # ['a', 30, -2, 3.1]
# 追加列表中的所有元素
b_list.extend(['C', 'R', 'A'])
print(b_list) # ['a', 30, -2, 3.1, 'C', 'R', 'A']
# 追加区间中的所有元素
b_list.extend(range(97, 100))
print(b_list) # ['a', 30, -2, 3.1, 'C', 'R', 'A', 97, 98, 99]

       insert()方法：

              指定将元素插入列表的具体位置

                     例如：

c_list = list(range(1, 6))
print(c_list) # [1, 2, 3, 4, 5]
# 在索引3处插入字符串
c_list.insert(3, 'CRAZY' )
print(c_list) # [1, 2, 3, 'CRAZY', 4, 5]
# 在索引3处插入元组，元组被当成一个元素
c_list.insert(3, tuple('crazy'))
print(c_list) # [1, 2, 3, ('c', 'r', 'a', 'z', 'y'), 'CRAZY', 4, 5]

删除列表元素

       删除列表元素使用del语句， 可用于删除列表的元素，也可用于删除变量等。

       使用del语句既可删除列表中的单个元素，也可直接删除列表的中间一段。

              例如：

a_list = ['crazyit', 20, -2.4, (3, 4), 'fkit']
# 删除第3个元素
del a_list[2]
print(a_list) # ['crazyit', 20, (3, 4), 'fkit']
# 删除第2个到第4个（不包含）元素
del a_list[1: 3]
print(a_list) # ['crazyit', 'fkit']
b_list = list(range(1, 10))
# 删除第3个到倒数第2个（不包含）元素，间隔为2
del b_list[2: -2: 2]
print(b_list) # [1, 2, 4, 6, 8, 9]
# 删除第3个到第5个（不包含）元素，间隔为2
del b_list[2: 4]
print(b_list) # [1, 2, 8, 9]

name = 'crazyit'
print(name) # crazyit
# 删除name变量
del name
#print(name) # NameError

       remove()方法来删除列表元素，

       该方法并不是根据索引来删除元素的，而是根据元素本身来执行删除操作的。

       该方法只删除第一个找到的元素，如果找不到该元素，该方法将会引发ValueError 错 误。

              例如：

c_list = [20, 'crazyit', 30, -4, 'crazyit', 3.4]
# 删除第一次找到的30
c_list.remove(30)
print(c_list) # [20, 'crazyit', -4, 'crazyit', 3.4]
# 删除第一次找到的'crazyit'
c_list.remove('crazyit')
print(c_list) # [20, -4, 'crazyit', 3.4]

       clear()方法，该方法用于清空列表的所有元素。

              例如：

c_list.clear()
print(c_list) # []

修改列表元素

       通过索引对列表元素赋值，可使用正数索引，也可使用负数索引。

       程序也可通过slice语法对列表其中一部分赋值，在执行这个操作时并不要求新赋值的

       元素个数与原来的元素个数相等。

                  例如：

a_list = [2, 4, -3.4, 'crazyit', 23]
# 对第3个元素赋值
a_list[2] = 'fkit'
print(a_list) # [2, 4, 'fkit', 'crazyit', 23]
# 对倒数第2个元素赋值
a_list[-2] = 9527
print(a_list) # [2, 4, 'fkit', 9527, 23]

b_list = list(range(1, 5))
print(b_list)
# 将第2个到第4个（不包含）元素赋值为新列表的元素
b_list[1: 3] = ['a', 'b']
print(b_list) # [1, 'a', 'b', 4]

       对列表中空的slice赋值，就变成了为列表插入元素。

              例如：

# 将第3个到第3个（不包含）元素赋值为新列表的元素，就是插入
b_list[2: 2] = ['x', 'y']
print(b_list) # [1, 'a', 'x', 'y', 'b', 4]

       将列表其中一段赋值为空列表，就变成了从列表中删除元素。

              例如：

# 将第3个到第6个（不包含）元素赋值为空列表，就是删除
b_list[2: 5] = []
print(b_list) # [1, 'a', 4]

       对列表使用slice语法赋值时，不能使用单个值；如果使用字符串赋值，Python会自动把字符串当成序列处理，其中每个字符都是一个元素。

              例如：

# Python会自动将str分解成序列
b_list[1: 3] = 'Charlie'
print(b_list) # [1, 'C', 'h', 'a', 'r', 'l', 'i', 'e']

       指定step参数。但如果指定了step参数，则要求所赋值的列表元素个数与所替换的列表元素个数相等

              例如：

c_list = list(range(1, 10))
# 指定step为2，被赋值的元素有4个，因此用于赋值的列表也必须有4个元素
c_list[2: 9: 2] = ['a', 'b', 'c', 'd']
print(c_list) # [1, 2, 'a', 4, 'b', 6, 'c', 8, 'd']

列表的其他常用方法

       在交互式解释器中输入dir(list)即可看到列表包含的所有方法：  

              >>>dir(list)

              [append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

       常用方法如下：

       count()：用于统计列表中某个元素出现的次数。

       index()：用于判断某个元素在列表中出现的位置。

       pop()：用于将列表当成“栈”使用， 实现元素出栈功能。可实现先入后出（FILO）

       reverse()：用于将列表中的元素反向存放。

       sort() 用于对列表元素排序。

count()例如：

a_list = [2, 30, 'a', [5, 30], 30]
# 计算列表中30的出现次数
print(a_list.count(30)) # 2
# 计算列表中[5, 30]的出现次数
print(a_list.count([5, 30])) # 1

index()例如：

a_list = [2, 30, 'a', 'b', 'crazyit', 30]
# 定位元素30的出现位置
print(a_list.index(30)) # 1
# 从索引2处开始、定位元素30的出现位置
print(a_list.index(30, 2)) # 5
# 从索引2处到索引4处之间定位元素30的出现位置，找不到该元素
print(a_list.index(30, 2, 4)) # ValueError

pop()例如：

stack = []
# 向栈中“入栈”3个元素
stack.append("fkit")
stack.append("crazyit")
stack.append("Charlie")
print(stack) # ['fkit', 'crazyit', 'Charlie']
# 第一次出栈：最后入栈的元素被移出栈
print(stack.pop())
print(stack) # ['fkit', 'crazyit']
# 再次出栈
print(stack.pop())
print(stack) # ['fkit']

（push()方法在其他语言中实现入栈操作，但Python并没有，我们可以使用append()方法来代替push()方法实现入栈操作）。所有语言类似，出栈操作既会移出列表的最后一个元素，也会返回被移出的元素。

reverse()例如：

a_list = list(range(1, 8))
# 将a_list列表元素反转
a_list.reverse()
print(a_list) # [7, 6, 5, 4, 3, 2, 1]

sort()对列表元素进行排序

a_list = [3, 4, -2, -30, 14, 9.3, 3.4]
# 对列表元素排序
a_list.sort()
print(a_list) #[-30, -2, 3, 3.4, 4, 9.3, 14]
b_list = ['Python', 'Swift', 'Ruby', 'Go', 'Kotlin', 'Erlang']
# 对列表元素排序：默认按字符串包含的字符的编码大小比较
b_list.sort()
print(b_list) # ['Erlang', 'Go', 'Kotlin', 'Python', 'Ruby', 'Swift']

还可以传入两个参数:

              key参数：为每个元素都生成一个比较大小的“键”；

              reverse参数：执行是否需要反转排序——默认是从小到大排序；True：从大到小

# 指定key为len，指定使用len函数对集合元素生成比较的键，
# 也就是按字符串的长度比较大小
b_list.sort(key=len)
print(b_list) # ['Go', 'Ruby', 'Swift', 'Erlang', 'Kotlin', 'Python']
# 指定反向排序
b_list.sort(key=len, reverse=True)
print(b_list) # ['Erlang', 'Kotlin', 'Python', 'Swift', 'Ruby', 'Go']

       在Python 2.x中，列表的sort()方法中可传入一个比较大小的函数，该函数负责比较列表元素的大小。该函数包含两个参数，返回正数，参数1>参数2，返回负数，参数1<   参数2，返回0，参数相等。

# 以下代码只能在Python 2.x中执行
# 定义一个根据长度比较大小的比较函数
def len_cmp(x, y):
    # 下面代码比较大小的逻辑是：长度大的字符串就算更大
    return 1 if len(x) > len(y) else (-1 if len(x) < len(y) else 0)
b_list.sort(len_cmp)
print(b_list) #['Go', 'Ruby', 'Swift', 'Erlang', 'Kotlin', 'Python']