Python基础-数据类型之列表

一、列表的定义

name = ["小明", "小红", "笑笑"]

二、列表的使用

除了序列中的操作，列表还有一些其他的操作。

（1）不使用列表方法对列表进行修改

1：通过索引修改列表中的值

name = ["Kitty", "Julie", "Ross"]
name[1] = "egon"
print(name)     # ["Kitty", "egon", "Ross"]

2：通过切片修改一定范围的值（切片赋值），替换的长度等于被替换的长度

list_str = ["k","i","t","t","y"]
list_str[1:3] = "ab"
print(list_str)         # ["k","a","b","t","y"]

3：切片赋值替换原列表中长度不同的值（替换的长度大于/小于被替换的长度）

list_str = ["k","i","t","t","y"]
print(list_str[1:3])      # ['i', 't']
# 替换的长度大于被替换的长度
list_str[1:3] = "python"
print(list_str)           # ['k', 'p', 'y', 't', 'h', 'o', 'n', 't', 'y']
# 替换的长度小于被替换的长度
list_str[1:3] = "p"
print(list_str)           # ['k', 'p', 't', 'y']

4：在列表中插入值

4.1：在某个具体的索引位置进行插入

例：已知list_str = ["k","y"]，得到list_str = ["k","i","t","t","y"]

list_str = ["k","y"]
print(list_str[1:1])    # []
list_str[1:1] = ["i","t","t"]
print(list_str)       # ['k', 'i', 't', 't', 'y']

注释：list_str[1:1]表示在列表list_str中索引为1的位置占了一个位置，然后将["i","t","t"]进行解包，将每个元素从索引1开始，依次进行插入

4.2：在某个具体的位置，将值替换掉

例：已知nums = [2,3,4]，想要得到nums=[2,5,6,7,4]

nums = [2,3,4]
print(nums[1:2])      # [3]
nums[1:2] = [5,6,7]
print(nums)           # [2, 5, 6, 7, 4]

在这里，我犯了一个错误，认为nums[1]和nums[1:2]得到的结果是一样的，于是我就直接把nums[1]=[5,6,7]，最后得到的结果是[2,[5,6,7],4]，才发现nums[1]和nums[1:2]得到的结果是不一样的，只是它两的值是一样的都是3，nums[1]得到的是一个具体的值3，nums[1:2]得到的结果是一个列表[3],而nums[1]=[5,6,7]就是将索引1的值替换成了一个列表。

5：删除列表中的元素

5.1：切片删

例：已知list_str = ["k","i","t","t","y"]，得到list_str = ["k","i","y"]

list_str = ["k","i","t","t","y"]
list_str[2:4] = []
print(list_str)      # ['k', 'i', 'y']

5.2：使用del删除

list_str = ["k","i","t","t","y"]
del list_str[2:4]
print(list_str)      # ['k', 'i', 'y']

（2）使用列表方法进行操作列表

1：增加元素append()，在列表的末尾追加一个对象

使用方法：list.append(object)

返回值为：None，修改了原列表

nums = [1,2,3,4]
result = nums.append(5)
print(result)      # None
print(nums)        # [1, 2, 3, 4, 5]

2：增加元素extend()，在列表的末尾一次性追加另一个序列的多个值

使用方法：list.extend(object)

返回值为：None，修改了原列表

# 追加列表
nums = [1,2,3,4]
nums1 = [5,6,7,8]
result = nums.extend(nums1)
print(result)        # None
print(nums)          # [1, 2, 3, 4, 5, 6, 7, 8]
print(nums1)         # [5, 6, 7, 8]
# 追加元组
nums = [1,2,3,4]
nums1 = (5,6,7,8)
result = nums.extend(nums1)
print(result)        # None
print(nums)          # [1, 2, 3, 4, 5, 6, 7, 8]
print(nums1)         # (5, 6, 7, 8)
# 追加字符串
nums = [1,2,3,4]
nums1 = "abc"
result = nums.extend(nums1)
print(result)        # None
print(nums)          # [1, 2, 3, 4, 'a', 'b', 'c']
print(nums1)         # abc

两个列表相加，也是将一个列表中的值追加到另一个列表的末尾。

与extend()方法有什么区别呢？

extend()的返回值为None，是在原列表的基础上进行追加的；

而两个列表相加，返回值为一个列表对象，会得到一个新列表，不修改原列表。

3：增加元素insert()：将对象插入到列表指定的索引位置。

list.insert(index, object)

返回值为：None，修改了原列表

nums = [1,2,3,4]
# 插入列表
result = nums.insert(2, [5,6,7])
print(result)       # None
print(nums)         # [1, 2, [5, 6, 7], 3, 4]
# 插入一个元素，a
result = nums.insert(2, 'a')    # 还可以用：nums[2:2] = 'a'
print(nums)         # [1, 2, 'a', 3, 4]

4：删除元素pop()，移除列表中的元素，不指定索引默认删除列表中的最后一个元素，指定索引删除对应索引的元素

list.pop(index)    # index不填，默认为0

返回值为：被删除元素的值，修改了原列表

nums = [1,2,3,4]
# result = nums.pop()
# print(result)         # 4
# print(nums)           # [1, 2, 3]
result = nums.pop(2)    # 指定删除索引为2的元素
print(result)           # 3
print(nums)             # [1,2,4]

5：删除元素remove()，用于删除列表中的第一个匹配项，如果没有匹配到，则会报错。

list.remove(object)

返回值为：None，修改了原列表

nums = [1, 2, 3, 1, 4, 5, 1]
result = nums.remove(1)      # 删除元素1
print(result)                # None
print(nums)                  # [2, 3, 1, 4, 5, 1]
nums.remove(6)               # 报错：ValueError: list.remove(x): x not in list

6：清空列表clear()

list.clear()

返回值为None，修改了原列表

nums = [1,2,3,4]
result = nums.clear()
print(result)         # None
print(nums)           # []

7：查找/统计元素count()，统计某个元素在列表中出现的次数，如果元素不存在，返回0。可用来查找一个元素是否在列表中，返回值为0表示，这个元素不在列表中。

list.count(object)

返回值为：元素出现的次数，不改变原列表

nums = [1, 2, 3, 1, 4, 5, 1]
result = nums.count(1)       # 统计元素1的出现次数
print(result)                # 3
result1 = nums.count(6)      # 统计元素6的出现次数
print(result1)               # 0

8：查找元素index()，从列表中找出某个值第一个匹配的索引位置，如果匹配不到，则报错。

list.index(object, startindex, endindex)     # startindex表示查询范围的起始位置，endindex表示查询范围的结束位置

返回值为：出现元素的第一个索引值，不改变原列表

nums = [2, 3, 1, 4, 1, 5, 6, 1]
result = nums.index(1)         # 不指定查询范围，查询元素1出现的位置
print(result)                  # 2
result1 = nums.index(1, 3, 6)  # 指定查询范围，查询元素1出现的位置
print(result1)                 # 4
result2 = nums.index(1, 5)     # 指定查询范围，只指定开始位置，查询元素1出现的位置
print(result2)                 # 7
result3 = nums.index(7)        # 报错，ValueError: 7 is not in list

要判断一个元素是否在列表中，有三种方法：

第一种，使用成员运算符in（not in），存在返回True，不存在返回False

第二种，使用count()方法，存在，返回值不为0，不存在，返回值为0

第三种，使用index()方法，存在，返回元素所在的第一个索引，不存在，报错

9：翻转列表reverse()，将列表中的元素反向存放

list.reverse(object)

返回值为：None，修改了原列表

nums = [1,2,3,4,5]
result = nums.reverse()
print(result)         # None
print(nums)           # [5, 4, 3, 2, 1]

还可以使用[::-1]进行翻转列表，返回值是一个新列表，不修改原列表

nums = [1,2,3,4,5]
result = nums[::-1]     
print(result)         # [5, 4, 3, 2, 1]
print(nums)           # [1, 2, 3, 4, 5]

10：排序sort()，对原列表进行排序，排序时列表中的元素之间必须是相同的数据类型，不可混搭，否则报错。

list.sort(key, reverse)      # 不填写参数，默认从小到大进行排序；如果指定参数，则使用比较函数指定的比较函数

key：用于指定一个函数，即key=函数，即为排序提供一种方法，函数需要有返回值。

reverse：排序规则，按照升序/降序进行排序，默认值为reverse = False（升序），reverse = True（降序）

返回值为：None，修改了原列表

nums = [3, 5, 2, 7, 1]
result = nums.sort()
print(result)         # None
print(nums)           # [1, 2, 3, 5, 7]
result1 = nums.sort(reverse=True)
print(nums)           # [7, 5, 3, 2, 1]

参数key的使用：

a = ['p', 'pyt', 'py', 'pytho', 'pyth', 'python']
a.sort(key=len) # key=len,len指的是len()这个方法，表示按照列表中的元素长度进行排序，默认升序
print(a)        # ['p', 'py', 'pyt', 'pyth', 'pytho', 'python']

将key与lambda匿名函数结合

a = [('AZ','abc',154),('BZ','aac',144),('AB','abd',253)]
# 按照第二个元素进行升序排序
a.sort(key=lambda i:i[1])
print(a)   # [('BZ', 'aac', 144), ('AZ', 'abc', 154), ('AB', 'abd', 253)]

11：复制copy()，对列表进行复制

nums = [1, 2, 3, 4]
nums_copy = nums.copy()
print(nums_copy)           # [1, 2, 3, 4]
print(id(nums_copy), id(nums))    # 2702229178248 2702229178696

对单层列表进行复制，是完全复制的，得到的是一个完全新的列表，对应的是两个不同的内存地址

注意：对一个复杂对象的子对象（序列里面嵌套序列，字典里面嵌套序列）并不会完全复制。

nums = [1, 2, 3, ['a', 'b']]
nums_copy = nums.copy()
print(nums_copy)         # [1, 2, 3, ['a', 'b']]
print(id(nums_copy), id(nums))       # 1883311377224 1883311376264
print(id(nums[3]), id(nums_copy[3]))   # 1883311376712 1883311376712

第一层列表对应的内存地址是不同，而第二层列表对应的地址是相同的，所以修改nums第二层列表中的值，nums_copy第二层的值会一起被修改

nums = [1, 2, 3, ['a', 'b']]
nums_copy = nums.copy()
print(nums_copy)         # [1, 2, 3, ['a', 'b']]
print(id(nums_copy), id(nums))       # 1883311377224 1883311376264
print(id(nums[3]), id(nums_copy[3]))   # 1883311376712 1883311376712
nums[3][1] = 'abcd'
print(nums, nums_copy)  # [1, 2, 3, ['a', 'abcd']] [1, 2, 3, ['a', 'abcd']]

要进行完全复制，需要导入copy库的deepcopy，deepcopy()可以对一个复杂对象进行完全复制

nums = [1, 2, 3, ['a', 'b']]
from copy import deepcopy
nums_deepcopy = deepcopy(nums)
print(nums_deepcopy)      # [1, 2, 3, ['a', 'b']]
print(id(nums), id(nums_deepcopy))   # 1759708448648 1759708449672
print(id(nums[3]), id(nums_deepcopy[3]))  # 1759708449096 1759708465288
nums[3][1] = 'abcd'
print(nums, nums_deepcopy) # [1, 2, 3, ['a', 'abcd']] [1, 2, 3, ['a', 'b']]

12：sum()：列表中的元素相加，相加要确保列表中的元素是同一数据类型

sum(object)

返回值为：相加后的结果，不修改原列表

列表中的数据类型为：数字

list_sum = [1, 2, 3, 4, 5]
result = sum(list_sum)
print(result)  # 15

列表中嵌套了列表

list1 = [["a", "b", "c"], ["d", "e", "f"],["g", "h"]]，想得到["a", "b", "c", "d", "e", "f", "g", "h"]

list1 = [["a", "b", "c"], ["d", "e", "f"],["g", "h"]]
result1 = sum(list1, [])
print(result1)  # ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']

sum()是把列表中的每个元素相加，即["a", "b", "c"]+ ["d", "e", "f"]+["g", "h"]，列表的相加即为扩展列表的元素，为啥要有第二个参数[]，因为sum()的第二个参数默认为0，而0是整型，整型不能与列表相加，所以需要加入参数[]。

列表中的元素为字符串，不能使用sum()

list2 = ["a", "b", "c"]
result2 = sum(list2,'')  
# 报错，TypeError: sum() can't sum strings [use ''.join(seq) instead]
# sum（）无法对字符串求和