列表【sort(key)，remove】与元组

列表list【可更改，索引正向从0开始，逆向从-1开始】

将多个元素用逗号隔开，放入方括号中称为列表 l=[]

有关列表的函数

1. 求长len(list)
2. 求最大值max(list)
3. 求最小值min(list)
4. 将元组转换为列表list(tuple)

有关列表的方法

序号	方法
1	list.append(obj) 在列表末尾添加新的对象
2	list.count(obj) 统计某个元素在列表中出现的次数
3	list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4	list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
5	list.insert(index, obj) 将对象插入列表
6	list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7	list.remove(obj) 移除列表中某个值的第一个匹配项
8	list.reverse() 反向列表中元素
9	list.sort( key=None, reverse=False) 对原列表进行排序
10	list.clear() 清空列表
11	list.copy() 复制列表

3. extend【加的元素会被拆分】

l=['a','b','c']
l2='defg'
l.extend(l2)
print(l)
l3=['h','i','g']
t=('klm')
l.extend(l3)
l.extend(t)
print(l)
#['a', 'b', 'c', 'd', 'e', 'f', 'g']
#['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'g', 'k', 'l', 'm']

'''
l=[1,2,3]
l2=[4,5,6]
l.append(l2)#会将l2作为一个元素，加到l的后面
print(l)#l[3]为[4,5,6]
结果：[1, 2, 3, [4, 5, 6]]
'''

4. index(obj,start,end)【匹配元素obj,起始位置，结束位置】【未找到元素obj报ValueError】

        起始位置与结束位置没有强制要求

        即使起始位置小于0或结束位置大于list最大长度，也是从list的0匹配到最大索引

5. insert(index,obj)【要插入的位置，插入的元素】【从插入位置的后续元素全部进行后移】

         当插入位置小于0时，随机插入

         当插入位置大于list最大长度，进行尾插

l=['a','b','d','e','a','b','c','d']
print(l.index('a',2,6))
l.insert(l.index('d'),'c')#在'd'的前面插入新元素
#l.insert(0,'c')#进行头插
print(l)

6. pop([index])【删除指定index的元素，index默认为-1】

l=[1,2,3,4,'q',5,6]
print(l.pop(0))
print(l.pop(l.index('q')))
print(l)

'''
1
q
[2, 3, 4, 5, 6]
'''

7. remove【与del】【remove未找到删除元素报错】

l=['a','b','c']
l.remove('b')#l.remove(l[1])
# del l[1]
print(l)#上两句均是删除索引为1的元素，并将后续向前移动

l=[1,2,3,4,5,6]
del l[2:5]
print(l)

使用remove或del正遍历删除符合预期时便会涉及到长度不断减少，使用for会出现IndexError，

逆遍历会出现元素前移 ，使用for会出现元素多打印

#正遍历删除
l=[1,2,3,4,5,6,7,8,9,10,11]
for i in range(len(l)):
    if l[i]%5 == 0:
        l.remove(l[i])
    print(l[i],end=',')
#逆遍历删除
l=[1,2,3,4,5,6]
for i in range(len(l)-1,-1,-1):
    if l[i]%5 == 0:
        l.remove(l[i])
    print(l[i],end=',')

l=[1,2,3,4,5,6]
#使用for循环
for i in range(len(l)-1,-1,-1):#下面更改在下次循环前失效
    if l[i]%5 == 0:
        del l[i]#l.remove(l[i])
        i-=1
    print(l[i],end=',')#没有达到打印一遍的需求
#使用while循环
j=len(l)
while 1:
    j-=1
    if j <0:
        break
    if l[j]%5 == 0:
        l.remove(l[j])
        j-=1
    print(l[j])

9. sort【在原对象的基础上进行更改，返回None】 

l.sort(key=None,reverse=False)#reverse=True为降序，为False为升序；key按照什么进行排序，

p = [('a',22.5,120),('b',65.1,79),('c',23.4,36),('d',22.5,128)]
print(p)
p.sort(key=lambda t:t[2],reverse=False)#对[120,79,36,128]进行排序
#print(p.sort(key=lambda t:t[2],reverse=False))#此行打印出None
#使用匿名函数，参数为t，按照每行的索引为2的元素进行排序【二维表的列】
print(p)

11. copy【重新创建对象】

l=['a','b','c']
l2=l.copy()#不是一个对象
l3=l#是一个对象
print(id(l),id(l2),id(l3))#l与l3的地址相同同属于一个对象
l[2]='e'
print(l,l2,l3)#l与l3的'c'变为'e'，而l2不进行改变

除了使用copy方法外还可以使用+或切片来生成新的对象【例如

        l2+=l
        l3=l[:]

元组tuple【不可更改，加减乘除均会报错】【索引正向从0开始，逆向从-1开始】

将多个元素用逗号隔开，放入圆括号中称为元组【单个元素，可在元素后加一个逗号，以解除黄色警告】

t=(6,)

元组同列表一样具有相同函数

1. 求长len(tuple)
2. 求当前元组最大值max(tuple)【元组须是整型或浮点型组成的】
3. 求当前元组最小值min(tuple)【元组须是整型或浮点型组成的】
4. 将列表转换为元组tuple(tuple)

t=(3,4,2,9,12,56,1,5)
print(len(t))
print(max(t))
print(min(t))

元组的不可变是指向的内存中的内容不可变【试图更改数据时会报TypeError】

                             

 重新赋值绑定了新的地址，就不是原来的对象【列表也一样】