06-数据类型的常用操作-列表、元组常用操作

函数	描述
len(list)	计算列表元素个数
max(list)	返回列表元素最大值
min(list)	返回列表元素最小值
list(seq)	将元组、集合、转换为列表

方法	描述
list.insert(index, obj)	将对象插入列表中指定下标位置
list.append(obj)	在列表末尾添加新的成员
list.count(obj)	统计某个元素在列表中出现的次数
list.extend(seq)	在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.index(obj)	从列表中找出某个值第一个匹配项的索引位置
list.pop([index=-1])	移除列表中的一个元素（默认最后一个元素），并且返回该元素的值，按下标删除
list.remove(obj)	移除列表中左起第一个出现指定成员，按值删除
list.reverse()	反转排列列表中元素
list.sort( key=None, reverse=False)	对原列表进行排序
list.clear()	清空列表
list.copy()	浅复制列表

"""计算列表成员数量"""
data = [1, 2, 3]
print(len(data))  # 3

"""找出最大值，最小值"""
data = [11, 2, 13]
ret = max(data)
print(ret)  # 13

ret = min(data)
print(ret)  # 2

# 特殊情况：
data = [11, "2", 13]
ret = max(data)
print(ret)  # 报错
# 因为max和min内部使用了大小于号来比较的，所以如果一个列表中出现了不同数据类型，则无法计算最大最小值，反而报错

"""
添加成员
列表.append(成员)   # 列表末尾追加成员
列表.insert(index, 成员) # 在列表中下标位置初插入成员，插入以后，原下标对应的成员往后排序
"""

data = ["小明", "小黑", "小红"]
data.append("小白")
print(data) # ['小明', '小黑', '小红', '小白']

data = ["小明", "小红", "小白"]
data.insert(0, "小黑")
print(data)  # ['小黑', '小明', '小红', '小白']

"""列表修改成员的值"""
data = ["xiaoming", "xiaohong", "小白"]
data[-1] = "xiaobai"
print(data)  # ['xiaoming', 'xiaohong', 'xiaobai']

"""
列表.count(成员)
统计列表中指定成员的数量
"""
data = ["A", "B", "C", "A", "D", "A"]
ret = data.count("A")
print(ret)  # 3

"""
列表.extend(列表)
合并列表，把第二个列表的成员合并到第一个列表
"""
data = ["A", "B", "C"]
print(id(data), data)
data.extend(["X", "Y", "Z"])
print(data) # ['A', 'B', 'C', 'X', 'Y', 'Z']
print(id(data), data) # 从这里可以看到，data还是原来的data，并没有产生新的数据，还是使用原来的内存。

"""
列表.index() 查找指定成员的下标
不存在的话，会报错，ValueError: 'W' is not in list
存在，则返回当前成员在列表左起出现的第一个下标
"""
data = ["A", "B", "C", "A"]

ret = data.index("W")
print(ret) # 不存在，会报错，ValueError: 'W' is not in list

ret = data.index("A")
print(ret) # 0

"""
剔除成员，默认情况下剔除最后一个成员，也可以通过index选项剔除指定成员
在数据结构中，pop操作剔除最后一个成员这种操作，也被称之为"出栈"

列表.pop([index=-1])
[index=-1] 中括号表示当前index选项属于可选选项，index不填的情况默认值为-1
"""
data = ["A", "B", "C", "D"]
item = data.pop()
print(item) # D
item = data.pop()
print(item) # C
item = data.pop()
print(item) # B
item = data.pop()
print(item) # A
item = data.pop()
print(item) # 针对空列表，不能使用pop会报错！！！！IndexError: pop from empty list

# 也可以基于pop删除指定下标的成员
data = ["A", "B", "C", "D"]
ret = data.pop(1)
print(ret)  # B
print(data)  # ["A", "C", "D"]

"""
小明的面试题：基于循环去除列表中偶数成员
"""
data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for i in range(len(data)):
    if data[i] % 2 == 0:
        data.pop(i)
print(data)  # IndexError: list index out of range

"""
首先，列表本身是可变类型，所以内部成员会发生改变，但是内部成员的下标不是固定的，而是通过排列得到的，
所以当我们使用循环基于正序进行成员删除时，没删除一个成员，后面的所有成员都会往前排列，占据被删除的成员下标
"""

"""一个不成熟的解决方案，还是有bug，但是解决报错的问题"""
# remove() 删除指定元素，如果有重名元素从左至右第一个
data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for item in data:
    if item % 2 == 0:
        data.remove(item)
print(data)  # [1, 3, 5, 7, 9]

"""上面看似已经解决了问题，实际上并没有真的解决掉，当列表的数字是乱序的"""
data = [2, 1, 5, 3, 6, 4, 7, 8, 9, 10]
for item in data:
    if item % 2 == 0:
        data.remove(item)
print(data)  # [1, 5, 3, 4, 7, 9]

"""
列表只要在循环中进行正序删除(从左往右)都会存在这样的成员下标前置的问题，导致产生结果，与我们所期望的不一样。
所以，我们要改成逆序删除(从右往左)
"""
data = [2, 1, 5, 3, 6, 4, 7, 8, 9, 10]
length = len(data)
for i in range(length-1, -1, -1):   # i的值是9到0
    if data[i] % 2 == 0:
        data.pop(i)
print(data) # [1, 5, 3, 7, 9]

"""除了基于逆序删除以外，还有第二个方案可以解决上面正序删除的BUG, 思路：根据正序删除的BUG出现原因，是因为列表本身的成员下标变动导致的"""
data = [2, 1, 5, 3, 6, 4, 7, 8, 9, 10]
new_data = []
for i in data:
    if i % 2 != 0:
        new_data.append(i)
print(new_data) # [1, 5, 3, 7, 9]

"""列表.reverse() 反转列表"""
data = [2, 1, 5, 3, 6, 4, 7, 8, 9, 10]
data.reverse()
print(data)  # [10, 9, 8, 7, 4, 6, 3, 5, 1, 2]

"""打乱列表，对列表进行洗牌"""
import random

data = [1, 3, 5, 7, 9]
random.shuffle(data)
print(data)  

"""
列表排序[基础]，默认是正序排序，可以通过reverse选项设置为True，表示逆序排序
列表.sort()   # 正序排序，从小到大
列表.sort(reverse=True) # 逆序排序，从大到小
"""

data = [9, 5, 1, 3, 7]
data.sort()
print(data) # [1, 3, 5, 7, 9]

data = ["A", "D", "B", "E", "C"]
data.sort()
print(data)  # ['A', 'B', 'C', 'D', 'E']


# 特殊情况：sort排序也是基于大小于号进行先后排序的，所以列表中存在不同类型数据时。会报错。
data = ["A", "D", 9, 5, 1, "B", "E", "C"]
data.sort()
print(data)  # TypeError: '<' not supported between instances of 'int' and 'str'


"""逆序排序"""
data = [20, 13, 9, 5, 1, 11, 78, 1]
data.sort(reverse=True)
print(data) # [78, 20, 13, 11, 9, 5, 1, 1]

"""学了后面的匿名函数以后，排序的代码可以长这样的"""
data = ["A", "D", 9, 5, 1, "B", "E", "C"]
data.sort(key=lambda a: str(a))
print(data) # [1, 5, 9, 'A', 'B', 'C', 'D', 'E']

"""列表.clear() 清空列表"""
data = ["A", "B"]
data.clear()
print(data) # []，清空成员，但是还是在内存中保留了列表的内容空间

"""列表.clear() 和 del 列表 的区别"""
data = ["A", "B"]
del data
print(data)  # del删除的是内存空间，所以一旦执行以后，连变量都没有了，后面使用需要重新赋值，否则报错

"""复制列表(copy浅拷贝)  list.copy()"""
data1 = ["A", "B"]
data2 = data1
print("data2=", data2)  # ['A', 'B']
data2[1] = "C"
print("data2=", data2)  # ['A', 'C']
print("data1=", data1)  # ['A', 'C']，这里出现了当data2改变了成员以后，data1也被改变了。

# """
# 深拷贝和浅拷贝
# 赋值和引用的区别
# """

# 基于copy可以复制一个列表，可以某种程度上解决上面的BUG，但是某些特殊情况下还是有BUG的
data1 = ["A", "B"]
data2 = data1.copy()
print("data2=", data2) # data2= ['A', 'B']
data2[1] = "C"
print("data2=", data2) # data2= ['A', 'C']
print("data1=", data1) # data1= ['A', 'B']

 

元组的基本操作与列表是一样的。对于操作来说，元组只有count和index操作。