列表相关操作

一、列表类型：

是可变类型，元素可以是任意类型如：字符串元组列表数字等等

二、列表的创建：

list_a = ["a",1,(1,3)]

空列表：

a = [] 或者 a = list()

a = []
b = list()
print("空列表a:",a,"\n空列表a类型:",type(a))
print("空列表b:",b,"\n空列表a类型:",type(b))
# 输出结果：
'''
空列表a: [] 
空列表a类型: <class 'list'>
空列表b: [] 
空列表a类型: <class 'list'>
'''

三、列表通用操作

列表和字符串一样都有：索引取值，切片，+拼接，*乘法，max,min,len,成员运算

1.索引修改列表元素的值

x = [1,2,'3']
x[2] = 3
print("修改后的列表x:",x)
# 结果：
修改后的列表x: [1, 2, 3] # 可以看出通过索引取值重新赋值是可以修改里列表中的元素，但是索引只能修改单个，切片可以修改多个

2. 切片修改列表多个元素的值

# 2. 切片修改列表多个元素的值
list_one = ["我","是","阿","登"]
# 修改后面2个元素
list_one[2:] = ["向","佳","哥"]
print(list_one) # ['我', '是', '向', '佳', '哥']

3.通过切片还可以在某个元素前面插入元素

# 3. 通过切片还可以在某个元素前面插入元素
numbers = [1,7]
# 在7前面插入 4,5
numbers[1:1] = [4, 5]
print(numbers) # [1, 4, 5, 7]

4.通过切片删除元素，使切片等于[]即可：

# 4.通过切片删除元素，使切片等于[]即可：
students = ["向佳","徐州","淘宝","王润","勇哥"]
# 需求是删除 淘宝
students[2:3] = []
print(students) # ['向佳', '徐州', '王润', '勇哥']

5.del关键字删除列表或者删除单个元素或多个元素

# 5.del关键字删除列表或者删除单个元素或多个元素
students = ["向佳","徐州","淘宝","王润","勇哥"]
del students[2] # 删除指定索引的元素
print("删除指定索引的元素:",students) # ['向佳', '徐州', '王润', '勇哥']
del students[2:] # 删除多个元素
print("删除多个元素:", students) # ['向佳', '徐州']

四、列表方法

列表对象的常用方法汇总如下：

image.png

1.增

append(),在列表末尾追加元素。等同于list_a[len(list_a):len(list_a)] = [obj]

原地修改列表对象，是真正的列表尾部添加新的元素，速度最快，推荐使用

+运算符操作

并不是真正的尾部添加元素，而是创建新的列表对象；将原列表的元素和新列表的元素依次复制到新的列表对象中。这样，会涉及大量的复制操作，对于操作大量元素不建议使用。

a = [20,40]
print(id(a))  # 34038408
a = a + [50]
print(id(a))  # 34866696
# + 拼接门牌号变了，元组拼接也会变

extend()将目标列表的所有元素添加到本列表的尾部，属于原地操作，不创建新的列表对象

list.extend(seq),seq -- 元素列表，可以是列表、元组、集合、字典，若为字典,则仅会将键(key)作为元素依次添加至原列表的末尾

# extend方法原地添加 门牌号不变
list_a = [50,20]
print(id(list_a)) # 3891848
list_a.extend([5])
print(id(list_a))# 3891848
print(list_a) # [50, 20, 5]

extend参数序列是 元组 集合 字典
list_a = [50,20]
# 添加序列是元组
list_a.extend((10,3))
print(list_a) # [50, 20, 10, 3]

# 集合
list_a.extend({1,2})
print(list_a)  #[50, 20, 10, 3, 1, 2]
# 字典  字典添加的是他的key
list_a.extend({100:"100块",200:"200块"})
print(list_a) #[50, 20, 10, 3, 1, 2, 100, 200]

insert(index,obj) 指定位置插入元素

使用 insert()方法可以将指定的元素插入到列表对象的任意制定位置。这样会让插入位置后
面所有的元素进行移动，会影响处理速度。涉及大量元素时，尽量避免使用。类似发生这种
移动的函数还有：remove()、pop()、del()，它们在删除非尾部元素时也会发生操作位置后
面元素的移动

a = [1,5,6,7]
print(id(a)) # 5071496
a.insert(1, 100)
print(id(a))  # 5071496  发现门牌号不变
print(a)  # [1, 100, 5, 6, 7]
a.insert(0,"1")
print(a)            #  ['1', 1, 100, 5, 6, 7]

2.删

del 可以通过索引删除单个，也可以切片删除多个

# del 可以通过索引删除单个，也可以切片删除多个
a = [3,4,7,8,1]
del a[1]
print(a) # [3, 7, 8, 1]

del a[1:]
print(a) # [3]

pop()删除并返回指定位置元素，如果未指定位置则默认操作列表最后一个元素

b = [3,4,7,8,1]
s = b.pop()  # 返回删除的元素，可以用一个变量接收
print(s)  # 1
print(b)  # [3, 4, 7, 8]
m = b.pop(1)
print(m)  # 4
print(b)  # [3, 7, 8]

remove(obj) 删除首次出现的指定元素，若不存在该元素抛出异常

# remove(obj)删除首次出现的指定元素，若不存在该元素抛出异常
a = [10,20,30,40,50,20,30,20,30]
a.remove(20)
print(a) # [10, 30, 40, 50, 20, 30, 20, 30]
# 元素不存在会抛出异常
a.remove(100) # ValueError: list.remove(x): x not in list

3.改

索引赋值修改，只能修改一个，超出索引会报错！
切片赋值修改，可以修改多个

4.统计 count(obj) 元素统计相同的个数

# count(obj) 统计列表元素出现的次数int
a = [10,20,30,40,50,20,30,20,30]
b = a.count(30)
print(b)  # 3

5.len()返回长度

6.列表排序（reverse sort）

列表翻转reverse

a = ["fd",3,(3,6),"大哥"]
a.reverse()
print(a) # ['大哥', (3, 6), 3, 'fd']

reversed(seq) 迭代对象，翻转

# reversed(seq) seq是个迭代对象，可以是 tuple, string, list 或 range
# 字符串
seqString = 'Runoob'
print(list(reversed(seqString))) #['b', 'o', 'o', 'n', 'u', 'R']

# 元组
seqTuple = ('R', 'u', 'n', 'o', 'o', 'b')
print(list(reversed(seqTuple))) #  ['b', 'o', 'o', 'n', 'u', 'R']

# range
seqRange = range(5, 9)
print(list(reversed(seqRange))) # [8, 7, 6, 5]  

# 列表
seqList = [1, 2, 4, 3, 5]
print(list(reversed(seqList)))  # [5, 3, 4, 2, 1]

内置函数 reversed()也支持进行逆序排列，与列表对象 reverse()方法不同的是，内置函数
reversed()不对原列表做任何修改，只是返回一个逆序排列的迭代器对象。

内置函数 reversed()也支持进行逆序排列，与列表对象 reverse()方法不同的是，内置函数
reversed()不对原列表做任何修改，只是返回一个逆序排列的迭代器对象。
>>> a = [20,10,30,40]
>>> c = reversed(a)
>>> c
<list_reverseiterator object at 0x0000000002BCCEB8>
>>> list(c)
[40, 30, 10, 20]
>>> list(c)
[]
我们打印输出 c 发现提示是：list_reverseiterator。也就是一个迭代对象。同时，我们使用
list(c)进行输出，发现只能使用一次。第一次输出了元素，第二次为空。那是因为迭代对象
在第一次时已经遍历结束了，第二次不能再使用。

sort() 默认升序，参数reverse=True 降序

列表里面的元素要能比较才行，不能比较排序会报错

vowels = ['e', 'a', 'u', 'o', 'i']
vowels.sort() # 升序
print(vowels)       #    ['a', 'e', 'i', 'o', 'u']
# 列表里面的元素要能比较才行，不能比较排序会报错
aList = [123, 'Google', 'Runoob', 'Taobao', 'Facebook']
aList.sort(reverse=True) # 降序
print(aList)
TypeError: '<' not supported between instances of 'int' and 'str'

sorted(iterable, cmp=None, key=None, reverse=False)

sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

iterable -- 可迭代对象
cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）

n = [('b',2),('a',1),('e',3),('d',4)]
m = sorted(n,key=lambda x:x[1],reverse=True) # 新列表
print(m) # [('d', 4), ('e', 3), ('b', 2), ('a', 1)]

# 案例
>>> students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
>>> sorted(students, key=lambda s: s[2])            # 按年龄排序
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

max min sum函数

# max 返回最大值 min返回最小值 sum求和
a =  [3,10,20,15,9]
print(max(a)) #   20
print(min(a))  #  3

print(sum(a)) #   57

嵌套列表循环打印学生信息

要求打印学生信息输出到控制台成排

stu_info = [
["高小一",18,30000,"北京"],
["高小二",19,20000,"上海"],
["高小一",20,10000,"深圳"],
]

"""
从表信息可以发现需要打印三行，每一行需要打印4列学生信息.
可以用2个for循环，外层控制行数：3行 range(3) 
内层控制列数4列 range(4)

"""

print("==".center(100,"*"))
pass
for i in stu_info:
    for m in i:
        print(m,end="\t")
    print() # 内层循环，结束换行

浅拷贝原理: copy()

a=[0,1,2,3,4,5]
b=a
"""
    使用＝赋值后，相当于[0,1,2,3,4,5]对象同时被变量a和b同是引用和指向，此后，如果通过变量a或者变量b途径取修改这个列表对象，因为a和b指向的是同一个列表对象，列表对象本身改变后，所有通过引用它的变量输出来的数据都是改变的．
类似于，大家公用一个寝室，其中一个人把寝室的面貌改变了，那么所有人再去描述现在的寝室，它都是改变过后的样子．
    通过浅拷贝方法相当于其中一个人根据原来的寝室的面貌重新盖了一个寝室，所以a和b的改变与c的改变互不影响． 
"""
c=a.copy()

del a[1]  
'''
   各变量值为：
   a=[0, 2, 3, 4, 5]
   b=[0, 2, 3, 4, 5]
   c=[0, 1, 2, 3, 4, 5]
'''

b.remove(4)
'''
   各变量值为：
   a=[0, 2, 3, 5]
   b=[0, 2, 3, 5]
   c=[0, 1, 2, 3, 4, 5]
'''
c.append(9)
'''
   各变量值为：
   a=[0, 2, 3, 5]
   b=[0, 2, 3, 5]
   c=[0, 1, 2, 3, 4, 5, 9]
'''

当原对象存在多层嵌套的情况下，浅拷贝copy()只拷贝了最外层的数据结构，最外层所包含的数据变化时，是不会相互影响的，但是当原数据对象内部嵌套数据中的数据发生变化后，相应的浅拷贝后的对象也会发生变化．类似于一个公司，原来有一个宿舍，通过浅拷贝，重新造了一个相同建筑架构的宿舍．里面有物理墙体，电视，电脑，床位等，电视里播放着统一的画面．当公司改变了电视里播放的画面时，所有的宿舍都会发生改变．其中物理墙体，硬件电视等相当于最外层的对象结构，而电视里的画面就是内层嵌套的数据了。

arr = [{'name': 'wcl', 'age': 23}, {'name': 'wjy', 'age': 14}]
arr2 = arr.copy()
del arr[1]
arr[0]['age'] = 18　#或者arr2[0]['age'] = 18
print('arr', arr)
print('arr2', arr2)
# 结果为：

arr [{'name': 'wcl', 'age': 18}]
arr2 [{'name': 'wcl', 'age': 18}, {'name': 'wjy', 'age': 14}]

py_07列表操作和方法