小甲鱼第五章——列表

1.如何去创建一个列表：

使用中括号将数据包裹起来，数据之间用逗号隔开,就完成了列表的创建。例如：这就是一个列表

[1,2,3,4,5]

上面这个属于创建了一个匿名的列表，因为没有名字，所以创建完之后也没办法再次使用它，为了可以随时对他进行修改和引用，可以给它贴上一个变量名。

type()函数用于返回指定参数的类型，list即列表的意思

注意：python  支持将各种不同的的数据放在一起。例如：

mix = [520,"小甲鱼"，3.14，[1,2,3]]

上面这个列表里面有整数型，字符串，浮点型数据，甚至可以包含另一个列表。

那么你在不知道往列表里面放什么时，可以先创建一个空列表

2.向列表添加元素

可以往列表里面添加任何你想要添加的元素。添加元素到列表可以使用append方法：

但是注意：append不是一个内置函数，它是属于列表对象的一个方法，中间的  “ . ” 可以暂时理解为范围的意思。append（）这个方法属于一个叫number的列表的对象的，

append方法只支持一个参数，它的作用是在列表的末尾添加一个指定的元素。
如果希望添加多个数据，试试extend（）方法向列表末尾添加多个元素。其实extend（）事实上是使用一个列表来扩充另一个列表，所以它的参数是另一个列表。

a = ["苹果","香蕉"]
b = ["梨","草莓"]
a.extend(b)
print(a)

那么这段代码的返回值就是["苹果","香蕉","梨","草莓"]

a = ['苹果','香蕉']
a.extend(['梨','草莓'])
print（a）

那么这段代码的返回值就是["苹果","香蕉","梨","草莓"]

想要往列表任何一个位置添加元素，可以使用insert方法。

insert方法有两个参数，第一个参数是指定待插入的位置，（索引值）

第二个参数是待插入的元素值

举个例子：

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

那么这段代码的返回值就是：[1，2，3，4，5] 

如果第一个参数是零，那么就会在开头插入0

s = [1,2,3,4,5]
s.insert(0，0）

那么这段代码的返回值就是[0，1，2，3，4，5]

如果它的第一个参数是“len（s）”，那么他插入的永远是最后一个，比如：

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

 那么这段代码的返回值就是[0，1，2，3，4，5，6]

insert（）方法中代表位置的第一个参数还支持负数，代表与列表末尾的相对距离。

注意：在python中，第一个位置的索引值是0，第二个位置的索引值是1，第三个位置的索引值是2，以此类推

3.从列表当中获取元素

A. 通过索引值可以直接获得某个元素

eggs = ["鸡蛋","鸭蛋","鹅蛋","铁蛋"]
eggs[0]

这段代码的返回值就是"鸡蛋"

B.如果想要访问列表中最后一个元素，可以使用 len（）函数获取该列表的长度（元素个数），再减 1 就是这个列表最后一个元素的索引值:

eggs = ["鸡蛋","鸭蛋","鹅蛋","铁蛋"]
eggs[len(eggs)-1]

 这段代码的返回值就是“铁蛋”

去掉len函数也会有同样的效果，我们可以利用索引值为负数，表示从列表末尾反向索引：

eggs = ["鸡蛋","鸭蛋","鹅蛋","铁蛋"]
eggs[-2]

那么这段代码的返回值就是“鹅蛋”

C.如果一个列表中我们要将两个元素位置进行调换，我们可以这样操作：

eggs = ["鸡蛋","鸭蛋","鹅蛋","铁蛋"]
temp = eggs[1]
eggs[1] = eggs[3]
eggs[3] = temp
eggs

 那么这段代码的运行结果就是["鸡蛋","铁蛋","鹅蛋","鸭蛋"]

这里的temp只是一个临时变量，避免相互遮盖，那么我们还可以使用另一种更为简单的方法去实现这个功能：

eggs = ["鸡蛋","鸭蛋","鹅蛋","铁蛋"]
eggs[1], eggs[3] = eggs[3] , eggs[1]
eggs

 D.如果进行一种抽奖功能的程序，我们就可以利用“奖项/参与者”放入列表里面，然后配合random模块实现即可

import random
prize = ["鸡蛋","铁蛋","鹅蛋","鸭蛋"]
random.choice(prizes)

这段代码就回返回列表当中的任意一个数据

random中的choice()方法可以从一个非空序列（如列表）中随机获取一个元素。

E.上文我们提到过，列表当中还可以有一个子列表，所以我们如果要获取子列表当中的一个元素，就可以使用两次索引

eggs = [鸡蛋"","铁蛋",["天鹅蛋","企鹅蛋","加拿大蛋"]"鸭蛋"]
eggs[2] [2]

那么这段代码的运行结果就是“加拿大蛋”

如果想让一段代码倒序，我们可以这么做

eggs = ["鸡蛋","鸭蛋","鹅蛋","铁蛋"]
eggs[::-1]

那么这段代码的返回值就是 ["铁蛋","鹅蛋","鸭蛋","鸡蛋"] 

4.从列表当中删除

删除有三种方法可以实现：remove()  pop()  del

A. remove()方法需要指定一个待删除的元素：

eggs
["鸡蛋","铁蛋","鹅蛋","鸭蛋"]
eggs.remove("铁蛋")

这段代码的运行结果就是eggs["鸡蛋","鹅蛋","鸭蛋"]

使用remove删除一个元素的时候，我们并不需要知道这个元素具体的位置，但是如果指定元素不再这个列表当中，程序就会报错

#注意#：1.在使用remove时，如果列表中存在多个匹配元素，那么他只会删除第一个

                2.如果指定删除的元素不存在，那么整个程序就会报错。

B.pop()方法是将列表中的指定元素”弹“出来，也就是取出并删除该元素的意思，它的参数是一个索引值：

eggs = ["鸡蛋","鹅蛋","鸭蛋"]
eggs.pop(1)

这段代码首先会返回一下索引值，然后再去

那么这段代码的运行结果即使["鸡蛋","鸭蛋"]

如果你的opo()不带参数，那么pop()方法默认是弹出列表当中的最后一个元素。

eggs = ["鸡蛋","鸭蛋"]
eggs.pop()
"鸭蛋"

那么这段代码的运行结果就是”鸡蛋“

C.del语句

注意：它是一个python语句，而不是del的列表方法，或者是BIF（内置函数）

del eggs[0]

那么这段代码的运行结果就是  [  ]

del不仅可以用来删除列表当中的某些元素，还可以直接用来删除整个变量

D.还有一个可以直接删除全部列表的方法就是：clear方法

eggs = ["鸡蛋","鸭蛋"]
eggs.clear()

这段代码也是会返回一下eggs然后接着就是清空整个列表，最后的二到一个空列表。 

5.列表切片

切片语法的引入（slice）:

就是用冒号隔开两个索引值，左边是开始位置，右边是结束位置。

像这样：list[2:5]

注意：结束位置上的元素是不包括的,比如list[2:5]他就是不包括第五个索引值，只有2到4的索引值

如果省略了开始位置，就默认索引为0，如果省略了结尾位置，默认到结束。

直接举个例子：

list1 = ["钢铁侠","蜘蛛侠","蝙蝠侠","绿灯侠","神奇女侠"]
list2 = []
记住：这个是没写完的，这个是需要补的！

注意：列表切片并不会修改列表自身的租车给结构和数据，它其实是为列表创建一个新的拷贝（副本）并返回。

6.进阶玩法（列表切片）

列表切片其实还剋接受第三个参数，其·代表的是它的步长，默认值是1，下面将步长修改成2，就会得到这样的结果

list1 = [1,2,3,4,5,6,7,8,9]
list1[0:9:2]

那么这段代码的返回值就是[1,3,5,7,9]

其实该代码可以直接写成：list1[::2]效果是一样的

如果将步长设置成-1，就会变成这样：

list1[::-1]
[9,8,7,6,5,4,3,2,1]

记住，将步长设置为-1，就是将整个列表反过来了，

上面这些列表切片操作都是获取列表加工之后切片的拷贝，并不会影响到原有列表结构：

list1 = [1,2,3,4,5,6,7,8,9]
list1[::-2]
[9,7,5,3,1]
list1
[1,2,3,4,5,6,7,8,9]

但是如果将del列表用于列表切片，那么结果是这样的：

del list1[::2]
llist1
[2,4,6,8]

del直接作用于原始列表。

7.列表当中的一些常规操作符：

我们之前学过的大部分操作符，都可以运用在列表上面：

但是python并没有我们想象的那么智能，当列表当中包含多个元素的时候，一般默认从第一个元素开始比较，只要有一个PK赢了，默认整个列表赢了。

那么字符串也是一样的道理，而且我们前面也介绍过，字符串可以适用 + 进行拼接，使用 * 来进行自我复制，这两个字符串也同样可以运用与列表之中：

list1 = [123,456]
list2 = [234,123]
list3 = list1 + list2

此时我们将list3打印出来，那么就会返回这样的结果：

llst3

[123,456,234,123]

A. 加号（+ ）

：也叫做连接操作符，它允许把列表当中的多个对象合并在一起，其实就相当于extend方法实现的效果，一般情况下建议使用extend（）方法来扩展列表。

注意，连接操作符并不能实现列表添加新元素的操作。

list1 = [123,456]
list2 = list1 + 789

那么此时我们将list2打印出来，python就会报错，因为连接操作符并不能实现列表田间新元素的操作。

正确的应该是这样的：

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

那么这段代码的返回值就是：[1,2,3,4,5,6]

 

B. 乘号（ * ）

也叫做重复操作符，重复操作符也同样可以利用于列表之中

list1 = ["Fishc"]
list1 * 3

那么这段代码的运行结果就是：[”Fishc“，”Fishc“，”Fishc“] 

 C.成员关系操作符（in）和（not  in）

list1 = ["小猪","小猫","小狗","小甲鱼"]
"小甲鱼" in list1

这段代码的返回值就是Ture

 注意：in 和 in not  只能判断一个层次的成员关系，这跟break和 continue 语句只能跳出一层循环是一个道理。

old_list = ["西班牙","葡萄牙","葡萄牙","牙买加","匈牙利"]
new_list = []
for each in old_list:
    if each not in new_list:
        new_list.append(each)

print(new_list)
 

解释：单吗先行迭代遍历old_list的每一个元素，如果该元素不存在于new_list中便调用列表的append（）方法添加进去

D.嵌套列表

matrix = [[1,2,3],[4,5,6],[7,8,9]]#这就是嵌套列表
#其实嵌套列表还可以这么写，如下：
matrix = [[1,2,3],
          [4,5,6],
          [7,8,9]]#这样写的好处就是更为直观
那么这段代码的返回值就是[[1,2,3],[4,5,6],[7,8,9]]

E.访问嵌套列表：

这里面的元素我们可以通过循环来实现，迭代一个列表我们使用一层循环，迭代嵌套列表，我们就

要使用嵌套循环

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

通过下标也可以访问嵌套列表

matrix[0]

这段代码的返回值就是：[1,2,3]

那么我们要访问一个元素就要这样：

matrix[0][2]

那么这段代码的返回值就是3 

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

A = [0]*3
#此时这段代码的返回值就是[0,0,0]
for i in range(3):
    A[i] = [0]*3
#这段代码的返回值就是[[0,0,0],[0,0,0],[0,0,0]]

 G.is运算符也称之为”同一性运算符“

用于检验两个变量，是否指向同一个对象的一个运算符

x = "FishC"

y = "FishC

#现在去检测x is y  结果就是返回Ture

x = [1,2,3]
y = [1,2,3]
#现在去检测x is y  结果就是返回flase

那就说明python对不同对象的存储机制时不一样的。 

列表可变，字符串不可变，所以python对字符串就一起存放而对列表单独存放。

 

8.下面介绍几种常用的方法：

count（）方法

统计某个元素在列表中出现的次数。

list1 = [1,1,2,3,5,8,13,21]
list1.count(1)

这段代码的返回值是：2

index（）方法

的作用是返回某个元素在列表中第一次出现的索引值：

list1.index(1)

这段代码的返回值是：0

index（）方法

可以限定查找的范围

start = list.index(1) + 1

stop = len (list1)
list1.index(list1)
list1.index(1,start,stop)

这段代码的返回值是：1

reverse（）方法

将整个列表原地翻转

list1 = [1,1,2,3,5,8,13,21]
list.reverse()
list1

 这段代码的返回值是[21,13,8,5,3,2,1,1]

sort（）方法

的作用是对列表元素进行排序：

list1 = [8,9,3,5,2,6,10,1,0]
list.sort()
list1

这段代码的返回值就是：[0,1,2,3,5,6,8,9,10]

如何从大到小对一个列表进行排序：

先使用sort（）方法，列表会出现从小到大排好队，然后调用reverse（）方法原地翻转即可

sort（）这个方法有三个参数：

语法形式：

sort（func,key,reverse）

func和key参数用于设置排序的算法和关键字，默认是使用归并排序（属于《数据结构和算法》）

reverse，它作为sort（）的一个默认参数，它的默认值是sort（reverse = False），表示不颠倒顺序，只要把False改成Ture，列表就相当于从大到小顺序

list1 = [8,9,3,5,2,6,10,1,0]
list1.sort(reverse = Ture)
list1

这段代码的返回值就是：[10,9,8,6,5,3,2,1,0]

最后一个方法：copy

用来拷贝一个列表,就是给这串代码赋一个新的值

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

那么这段代码的返回值就是[3,1,9,6,8,3,5,3]

用切片的方法试一下拷贝整个列表

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

这段代码的返回值就是[3,1,9,6,8,3,5,3]

 #注意#

这两种拷贝方法在python当中我们都称之为shallow copy