列表
1. 列表
列表非常适合利用顺序和位置定位某一元素，尤其是当元素的顺序或内容经常发生改变时。与字符串不同，列表是可变的。你可以直接对原始列表进行修改：添加新元素、删除或覆盖已有元素。在列表中，具有相同值的元素允许出现多次。
2. 使用 [ ] 或list() 创建列表
列表可以由0个或多个元素组成，元素之间用 ， 分隔，整个列表被[ ]包裹
>>> empty_list = [] # 可以为空
>>> another_empty_list = list()
>>> name = ['jack','lili','lisa','jack'] # 可以重复
>>>
>>> empty_list
[]
>>> another_empty_list
[]
>>> name
['jack', 'lili', 'lisa', 'jack']
3. 使用list（）进行类型转换
字符串转列表
>>> list('cat')
['c', 'a', 't']
元组转列表
>>> a_tuple = ('a', 'b', 'c')
>>> list(a_tuple)
['a', 'b', 'c']
spilt转列表
>>> birthday = '1998/09/20'
>>> birthday.split('/')
['1998', '09', '20']
4.使用[ offset ]获取元素
和字符串一样，通过偏移量取值
>>> name = ['jack','lili','lisa','jack']
>>> name[1]
'lili'
>>> name[0]
'jack'
>>> name[-1]
'jack'
>>> name[-43]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
5.包含列表的列表
列表可以包含各种类型的元素 也包括列表
嵌套取值也是一目了然
>>> a_list = [ ['a', 'b', 'c'], 'd', ['e', 'f', ['g', 'h']]]
>>> a_list[0]
['a', 'b', 'c']
>>> a_list[2]
['e', 'f', ['g', 'h']]
>>> a_list[2][2]
['g', 'h']
>>> a_list[2][2][1]
'h'
6.使用[offset]修改列表
列表是可变的而字符串不可变，就像可以通过访问某元素一样，可以通过赋值更新它的内容
>>> name = ['jack','lili','lisa','jack']
>>> name[2] = 'Rison'
>>> name
['jack', 'lili', 'Rison', 'jack']
7.指定范围并使用切片提取元素
和字符串一样
通过切片还可以巧妙反转元素顺序！！
['jack', 'lili', 'Rison', 'jack']
>>> name[:2]
['jack', 'lili']
>>> name[::2]
['jack', 'Rison']
实现巧妙反转元素顺序
>>> name[::-1]
['jack', 'Rison', 'lili', 'jack']
8.append()添加元素至尾部
>>> name
['jack', 'lili', 'Rison', 'jack']
>>> name.append('Tom')
>>> name
['jack', 'lili', 'Rison', 'jack', 'Tom']
9.extend()或 += 合并列表
与append( )的区别是？
>>> name = ['jack', 'lili', 'Rison', 'jack', 'Tom']
第一种方式
>>> other = ['tommi', 'luci']
>>> name.extend(other)
>>> name
['jack', 'lili', 'Rison', 'jack', 'Tom', 'tommi', 'luci']
第二种方式
>>> name += other
>>> name
['jack', 'lili', 'Rison', 'jack', 'Tom', 'tommi', 'luci']
与append对比
append添加的是整个列表，extend是把两个列表合成一个
>>> name = ['jack', 'lili', 'Rison', 'jack', 'Tom']
>>> name.append(other)
>>> name
['jack', 'lili', 'Rison', 'jack', 'Tom', ['tommi', 'luci']]
10.insert()在指定位置插入元素
>>> name = ['jack', 'lili', 'Rison', 'jack', 'Tom']
>>> name.insert(2, 'tank') # name[2]变成tank其他元素向后移一位
>>> name
['jack', 'lili', 'tank', 'Rison', 'jack', 'Tom']
>>> name.insert(110, 'lucif') #超过则插入到尾部
>>> name
['jack', 'lili', 'Rison', 'jack', 'Tom', 'lucif']
11.del 删除指定位置元素
>>> name
['jack', 'lili', 'tank', 'Rison', 'jack', 'Tom', 'lucif']
>>> del name[-2]
>>> name
['jack', 'lili', 'tank', 'Rison', 'jack', 'lucif']
再一次
>>> name[-2]
'jack'
>>> del name[-2]
>>> name
['jack', 'lili', 'tank', 'Rison', 'lucif']
12.remove()删除具有特定值的元素
如果不确定或不关心元素在列表中的位置，可以直接使用remove（）更具特定值删除元素
>>> name = ['jack', 'lili', 'tank', 'Rison', 'jack', 'Tom', 'lucif']
>>> name.remove('tank')
>>> name
['jack', 'lili', 'Rison', 'jack', 'Tom', 'lucif']
13.pop()获取并删除指定位置元素
使用pop（）同样可以获取列表中指定位置的元素，但在获取完成后，该元素会被自动删除。
如果你为pop（）指定了偏移量，它会返回偏移量对应位置的元素；如果不指定，则默认使用-1.因此，pop（0）将返回列表的头元素，而pop()或pop（-1）则会返回列表的尾元素
>>> name
['jack', 'lili', 'Rison', 'jack', 'Tom', 'lucif']
>>> name.pop()
'lucif'
>>> name
['jack', 'lili', 'Rison', 'jack', 'Tom']
>>> name.pop(1)
'lili'
>>> name
['jack', 'Rison', 'jack', 'Tom']
14.index()查询具有特定值的元素
>>> name = ['jack', 'Rison', 'jack', 'Tom']
>>> name.index('Rison') # 找到就返回元素在列表中的位置
1
>>> name.index('1') # 找不到就报错
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: '1' is not in list
15.使用in判断值是否存在
>>> name = ['jack', 'lili', 'Rison', 'jack', 'Tom', 'lucif'] >>> 'jack' in name # 只要有一个 就返回True True >>> 'tank' in name False >>> 'Tom' in name True >>> 'tom' in name False
16.count()记录特定值出现的次数
>>> name = ['jack', 'lili', 'Rison', 'jack', 'Tom', 'lucif']
>>> name.count('jack')
2
>>> name.count('tank') # 没有也不会报错 返回0
0
>>> name.count('Rison')
1
17.join()转换成字符串
join()实际上是一个字符串方法
可以比作为split的逆过程
>>> friend = ['Tom', 'jack', 'Rison']
>>> separator = ' * '
>>> joined = separator.join(friend)
>>> joined
'Tom * jack * Rison'
>>> joined.split(' * ')
['Tom', 'jack', 'Rison']
18.sort()排列元素
-
列表方法sort( )会对列表内容排序，改变原列表
-
sorted( )则会返回排好序的副本， 不会改变原列表
如果列表都是数字默认情况下则会按照大小排，如果都是字符串，则会按照字母表排
>>> number = [23,4,644,6,1,0,-32]
>>> number.sort()
>>> number
[-32, 0, 1, 4, 6, 23, 644]
# 也可降序
>>> number.sort(reverse = True)
>>> number
[644, 23, 6, 4, 1, 0, -32]
>>> friend = ['Tom', 'jack', 'Rison']
>>> friend.sort()
>>> friend
['Rison', 'Tom', 'jack'] # 按照ASCII码表
当列表中既有数字又有字母时就会报错
>>> number.extend(friend)
>>> number
[-32, 0, 1, 4, 6, 23, 644, 'Rison', 'Tom', 'jack']
>>> number.sort()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'str' and 'int'
sorted（）
sorted
>>> number = [23,4,644,6,1,0,-32]
>>> sorted_number = sorted(number)
>>> number
[23, 4, 644, 6, 1, 0, -32]
>>> sorted_number
[-32, 0, 1, 4, 6, 23, 644]
19.len()获取长度
>>> number = [644, 23, 6, 4, 1, 0, -32]
>>> len(number)
7
-
= 赋值
l1 和 l2 指向的还是列表，所以修改列表指向的值，l1 和 l2都会变
>>> list1 = ['a', 2, 'book']
>>> list2 = list1
>>> id(list1)
1631911490952
>>> list1[0] = 'b'
>>> list2[1] = 20
>>> list1
['b', 20, 'book']
>>> list2
['b', 20, 'book']
>>> id(list1)
1631911490952
-
浅copy
对于浅copy来说，只是在内存中重新创建了开辟了一个空间存放一个新列表，但是新列表中的元素与原列表中的元素是公用的，且元素原地址一样不变。
-
第一种情况 指向的都是不可变类型 如 int 和 str
llist1 list2 指向的是不同id的列表，修改里面的不可变类型的值互不影响
-
三种方法
list1 = ['a', 2, 'book']
1. l2 = list1.copy()
2. l2 = list1[:]
3. l2 = list(list1)
第一种情况 列表里面全是不可变类型
list1 = ['a', 2, 'book']
list2 = list1[:]
>>> list1[0] = 'b'
>>> list2[1] = 20h
>>> list1
['b', 2, 'book']
>>> list2
['a', 20, 'book']
-
第二种情况 列表里面包含可变类型 比如列表
浅copy的结果
看到这里就很明显了，虽然list1 和 list2 指向的是不同的id列表，但是这时候不就和 = 赋值时一样了吗？
所以得出结论是，浅copy时，内存会开辟一个新的空间存放一个新的列表，所以地址不一致。列表中的元素和元素地址都会被copy过来，而可变数据类型（列表中的列表，二级列表）被当作一个整体不被拷贝，所以地址永远一致，对可变数据类型中的元素改变时，a和b会相互影响，元素永远相同。
>>> list1 = ['a', 2, ['c', 'd']]
>>> list2 = list1[:]
>>>
>>> list1[2][1] = 2
>>> list2[2][0] = 1
>>>
>>> list1
['a', 2, [1, 2]]
>>> list2
['a', 2, [1, 2]]
>>> id(list1)
2154076146632
>>> id(list2)
2154078522888
>>> id(list1[2])
2154074887176
>>> id(list2[2])
2154074887176
-
-
深copy
如果我们能区分列表内的值是可变类型还是不可变类型，问题是不是就容易解决多了，如果是可变类型就分配新的id
一目了然 它是拷贝所有内容。包括内部（列表的列表）的所有，形成一个新的对象，虽然与之前的值和内容一模一样，但是它们时完完全全的两个对象
使用方法：
#导入copy模块
>>> import copy
>>> list1 = ['a','2',['c','d']]
>>> list2 = copy.deepcopy(list1) # 使用copy模块中的deepcopy方法
>>>
>>> list1
['a', '2', ['c', 'd']]
>>> list2
['a', '2', ['c', 'd']]
>>> id(list1[2])
1771359119112
>>> id(list2[2])
1771359124616
>>>
>>>
>>> list1[2][0] = 1 # 互不影响
>>> list2[2][1] = 2
>>> list1
['a', '2', [1, 'd']]
>>> list2
['a', '2', ['c', 2]]
可以区分开可变类型与不可变类型的copy机制，这就是深copy
