十二、列表1

1、创建列表及基本运算

1）使用中括号，将所有准备放入列表中的元素，包裹起来，不同元素之间使用逗号分隔。
举例：

[1,2,3,4,5]

2）列表可以容纳不同类型的数据。
举例：

[1,2,3,4,5,"上山打老虎"]

3）给列表添加变量名。
举例：

rhyme = [1,2,3,4,5,"上山打老虎"]
print(rhyme)

 
[1,2,3,4,5,'上山打老虎']

4）序列在Python中是最常见的数据结构，字符串和列表都是序列，按顺序访问列表上的每一个元素。

rhyme = [1,2,3,4,5,"上山打老虎"]
for each in rhyme:
    print(each)
 
    
1
2
3
4
5
上山打老虎

5）单独访问列表中的某一个元素，可以使用下标索引的方法。

rhyme = [1,2,3,4,5,"上山打老虎"]
rhyme[0]
1
rhyme[2]
3
rhyme[5]
'上山打老虎'

6）如果列表很长，如何访问最后一个元素。

length = len (rhyme)
rhyme[length -1]
'上山打老虎'
 
rhyme[-1]
'上山打老虎'

2、列表切片

1）输入需要获取的元素的范围。

rhyme[0:3]
[1, 2, 3]

2）简写元素范围

rhyme[:3]
[1, 2, 3]
rhyme[3:]
[4, 5, '上山打老虎']
rhyme[:]
[1, 2, 3, 4, 5, '上山打老虎']

3）跳着显示元素，第二个冒号后是设置列表步进的跨度值。

rhyme[0:6:2]
[1, 3, 5]
 
rhyme[::2]
[1, 3, 5]

4）倒序输出

rhyme[::-2]
['上山打老虎', 4, 2]
 
rhyme[::-1]
['上山打老虎', 5, 4, 3, 2, 1]

3、列表——增

1）append()，在列表的末尾添加一个指定的元素。

heros = ["钢铁侠","绿巨人"]
heros.append("黑寡妇")
heros
['钢铁侠', '绿巨人', '黑寡妇']

2）extend()，允许直接添加一个可迭代的对象。比如列表就是一个可迭代的对象。
注意：extend()方法的参数必须是一个可迭代的对象，新的内容是追加到原列表最后一个元素的后面。

heros = ["钢铁侠","绿巨人"]
heros.extend(["鹰眼","灭霸","雷神"])
heros
['钢铁侠', '绿巨人', '黑寡妇', '鹰眼', '灭霸', '雷神']

3）使用切片实现增加功能

s = [1,2,3,4,5]
s[len(s):]=[6]
s
[1, 2, 3, 4, 5, 6]
 
s[len(s):]=[7,8,9]
s
[1, 2, 3, 4, 5, 6, 7, 8, 9]

4）在列表的任意位置添加数据——insert()，第一个参数是插入的位置，第二个参数是插入的元素。

s=[1,3,4,5]
s.insert(1,2)
s
[1, 2, 3, 4, 5]

列表开头插入

s.insert(0,0)
s
[0, 1, 2, 3, 4, 5]

列表末尾插入

s.insert(len(s),6)
s
[0, 1, 2, 3, 4, 5, 6]

4、列表——删

1）将指定的元素删除，remove方法
注意：如果列表中存在多个匹配的元素，name它只会删除第一个。
如果指定的元素不存在，那么程序就会报错。

heros.remove("灭霸")
heros
['钢铁侠', '绿巨人', '黑寡妇', '鹰眼', '雷神']

2）删除某个位置上的元素，pop方法，它的参数就是元素的下标索引值

heros.pop(2)
'黑寡妇'
heros
['钢铁侠', '绿巨人', '鹰眼', '雷神']

3）清空列表，clear

heros.clear()
heros
[]

5、列表——改

列表和字符串最大的区别就是，列表是可变的，而字符串是不可变的。
替换列表中的元素和访问列表类似，都是使用下标索引的方法。用赋值运算符就可以将新的值给替换进去了。
1）单个元素的替换

heros = ["蜘蛛侠","绿巨人","黑寡妇","鹰眼","灭霸","雷神"]
heros[4]="钢铁侠"
heros
['蜘蛛侠', '绿巨人', '黑寡妇', '鹰眼', '钢铁侠', '雷神']

2）多个元素的替换——切片
A.将赋值号（=）左边指定的内容删除
B.将包含在赋值号（=）右边的可迭代对象中的片段插入左边被删除的位置

heros[3:]=["武松","林冲","李逵"]
heros
['蜘蛛侠', '绿巨人', '黑寡妇', '武松', '林冲', '李逵']

3）如果列表中都是数字，对列表中的元素从小到大排序，sort()方法
s.sort(key=None,reverse=False)，对列表中的元素进行原地排序（key参数用于指定一个用于比较的函数；reverse参数用于指定排序结果是否反转）

nums = [3,1,9,6,8,3,5,3]
nums.sort()
nums
[1, 3, 3, 3, 5, 6, 8, 9]

4）从大到小排序，revers()，原地反转列表中的元素

nums.reverse()
nums
[9, 8, 6, 5, 3, 3, 3, 1]


 
nums = [3,1,9,6,8,3,5,3]
nums.sort(reverse=True)
nums
[9, 8, 6, 5, 3, 3, 3, 1]

6、列表——查

1）查看列表中有多少个某元素，count方法

nums.count(3)
3

2）查找某个元素的索引值，index()

Index(x,start,end)，可以指定查找的开始和结束位置。
heros.index("绿巨人")
1

3）可以与替换结合使用，如果不知道某个元素的索引值，想替换该元素时。

heros[heros.index("绿巨人")]="神奇女侠"
heros
['蜘蛛侠', '神奇女侠', '黑寡妇', '武松', '林冲', '李逵']

4）浅拷贝1：拷贝列表，copy()

nums = [3,1,9,6,8,3,5,3]
nums_copy1 = nums.copy()
nums_copy1
[3, 1, 9, 6, 8, 3, 5, 3]

5）浅拷贝2：使用切片来实现拷贝

nums_copy2 = nums[:]
nums_copy2
[3, 1, 9, 6, 8, 3, 5, 3]

7、列表的运算

1）列表加法——拼接

s = [1,2,3]
t = [4,5,6]
s+t
[1, 2, 3, 4, 5, 6]

2）列表乘法——重复列表内部的所有元素若干次

s * 3
[1, 2, 3, 1, 2, 3, 1, 2, 3]

8、嵌套列表——二维列表

二维列表的直接应用就是举证。

matrix = [[1,2,3],[4,5,6],[7,8,9]]
matrix
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
 
matrix = [[1,2,3],
               [4,5,6],
               [7,8,9]]
matrix
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

9、访问嵌套列表

1）访问嵌套列表中的元素，可以使用循环来实现，迭代一个列表使用一层循环，迭代嵌套列表我们相应的使用嵌套循环。

for i in matrix:
    for each in i:
        print(each)
        
1
2
3
4
5
6
7
8
9
 
for i in matrix:
    for each in i:
        print(each,end="  ")
    print()
    
1  2  3  
4  5  6  
7  8  9  

2）通过下标访问嵌套列表

matrix[0]
[1, 2, 3]
matrix[0][0]
1

3）通过循环语句来创建并初始化二维列表

A = [0] * 3
A
[0, 0, 0]
for i in range(3):
    A[i] = [0] * 3
    
A
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]

需要注意有个错误写法

B = [[0] * 3] * 3
B
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]

因为当我们要修改其中某个元素的时候，则会发现不同

A [1][1] = 1
A
[[0, 0, 0], [0, 1, 0], [0, 0, 0]]
B [1][1] = 1
B
[[0, 1, 0], [0, 1, 0], [0, 1, 0]]

3）同一性运算符——is
is用于检验两个变量是否指向同一个对象的一个运算符，Python对于不同对象的存储机制是不一样的，字符串是不可变的，但列表是可变的，Python无法确定用户会何时向列表中添加或删除元素。

x = "Love"
y = "Love"
x is y
True
 
x=[1,2,3]
y=[1,2,3]
x is y
False

刚才的错误写法的校验和追根溯源

A[0] is A[1]
False
B[0] is B[1]
True

AB在Python中的内存布局如下：
B试图通过乘号对一个嵌套列表进行拷贝，但它拷贝的只是对同一个列表的引用。