列表

 

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

 

20. = 赋值 与 深浅copy

• = 赋值

  

  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