本章有部分超纲内容，可作为了解，提前学习学习。

列表

列表，主要使用[ ]来表示，我这里的加了一个空格，便于看清哦！看下面的例子

# 这里声明一个变量，后续便于输出class_name = ["10", "20", "30"]

上述就是一个简单的列表。那么如何访问呢，其实跟我之前的一样，直接打印就好了。另外，我们利用索引来取值，列表的左边第一个值，索引值为0，自左向右推，10索引值为0，20为1...

如上图所示。列表中的每一个值都会有对应的内存地址，我们看到的["10", "20", "30"]只是展现出来的value。而他们内部会有对应的内存地址去存储。如下：

a = [2,1]print(id(a[0]),id(a[1]))# 2613135173968 2613135173936

小例子：

# 这里声明一个变量，后续便于输出class_name = ["python", "java", "c", "php"]print(class_name)  # 打印class_name列表print(class_name[0])  # 索引输出pythonprint(class_name[1])  # 索引输出javaprint(class_name[-1])  # 这里的-1是打印列表最后一个值，从右往左索引值依次增加为：-1,-2...print(class_name[-2])  # 打印倒数第二个值

用上述的例子，我们可以恰当的使用其中一个值，上一节课讲过的哦：可以适当的举一反三哦！

# 这里声明一个变量，后续便于输出class_name = ["python", "java", "c", "php"]# 使首字母大写print(f"This is {class_name[0].title()}")

list()

下面我们将循环出来的数字变成列表形式

num = list(range(1,6))print(num)# [1, 2, 3, 4, 5]

也可以设置一定的步长，所谓的步长就是个几个数取一次值

num = list(range(1, 11, 2))print(num)# [1, 3, 5, 7, 9]num = list(range(11, 1, -1))print(num)# [11, 10, 9, 8, 7, 6, 5, 4, 3, 2]

range这里的可以这样理解：range(1,6)，在for循环中使用我们定义的num变量进行1~6之间的数字循环，但是因为range函数的本身的原因，所以6是不会打印的，如果要打印1~6所有的数字，就需要改一下range里面的参数。

对于字符串，list还能这个用：

print(list("托马有一只小羊"))# ['托', '马', '有', '一', '只', '小', '羊']

可以将一个字符串直接转为列表。

列表推导式

print([x*2 for x in range(6)])# [0, 2, 4, 6, 8, 10]a= []for i in range(6):    x = i * 2    a.append(x)print(a)

上述例子中，两者是一样的，或许各位对于第二个例子有更简单的写法，这里只是举例便于了解。

对于上述例子我们还能增加一些其他的使用，比如if判断：

print([x*2 for x in range(6) if x%2==0])# [0, 4, 8]

对于模除后满足结果为0的才输出，if判断此处作为了解，后续会详细讲解。

修改元素

# 这里声明一个变量，后续便于输出class_name = ["python", "java", "c", "php"]# 打印原来的值，便于比较print(class_name)# 利用索引进行修改里面的值class_name[0] = "html"    #修改列表的第一个元素class_name[1] = "大数据"    #修改列表的第二个元素print(class_name)

添加元素

添加的值附加在列表的末尾

# 这里声明一个变量，后续便于输出class_name = ["python", "java", "c", "php"]# 打印原来的值，便于比较print(class_name)# 在列表的末尾添加一个元素class_name.append("html")print(class_name)

还有一种extend，两者有什么区别？

list_ = ['a', 'b', 'c']list_1 = ['a', 'b', 'c']list_.append(['d', 'e'])list_1.extend(['f', 'g'])print(list_, list_1)

['a', 'b', 'c', ['d', 'e']] ['a', 'b', 'c', 'f', 'g']。extend() 方法只接受一个参数，而该参数总是一个列表，并 将列表 list_1 中所有的元素都添加到该列表中。 append() 方法只接受一个参数，但可以是任何数据类型。在此，对一个 3 元素列表调用 append() 方法,因为最后一个元素（刚刚 append［添加］ 的元素） 本身 是个列表 。列表可包含任何类型的数据，包括其它列表。

插入元素

# 这里声明一个变量，后续便于输出class_name = ["python", "java", "c", "php"]# 打印原来的值，便于比较print(class_name)# 在列表索引值0的位置前面插入一个元素class_name.insert(0, "html")print(class_name)

删除元素

有两种方法，一种是.del，一种是.pop()：两者的区别，让我们来理解一下吧：

del方法可以删除任意位置的列表元素，只需要知道它的索引值即可

删除后就无法再进行访问了

当你需要删除列表的值后，又需要使用它时，就可以用到.pop()方法了

.pop()是删除末尾的元素，也可以通过索引指定移出元素，这里的删除其实先当于将元素移出当前列表

class_name = ["python", "java", "c", "php"]# 通过索引来删除元素，删除后且无法再次使用del class_name[0]print(class_name)

# 这里声明一个变量，后续便于输出class_name = ["python", "java", "c", "php"]# 打印原来的值，便于比较print(class_name)# 移出末尾的值poppd = class_name.pop()# 打印我们之前移出的末尾的值print(f"This is {poppd.title()}")# eg:# 你也可以通过索引来指定移出哪个元素# poppd = class_name.pop(1)

根据值来删除元素：这个用法还是比较简单的，当你不知道想要删除的元素所处的位置时，就用指定值来删除指定元素.remove()：

# 这里声明一个变量，后续便于输出class_name = ["python", "java", "c", "php"]# 打印原来的值，便于比较print(class_name)class_name.remove("java")print(class_name)

remove方法删除值后其实也可以使用，看下面的例子：

class_name = ["python", "java", "c", "php"]class_remove = "java" # 定义一个变量接受赋值，指定删除javaclass_name.remove(class_remove) # 删除列表中的值，因为前面我们已经指定的删除谁print(f"I like {class_remove.title()}")

# reverse\(\)方法```python# 反转class_name = ["python", "bird", "c", "app"]# 这里我们倒叙打印放在print里面直接打印的话就会是空值print(class_name.reverse())# 需要用变量直接使用函数，再通过打印才行哦。注意输出以下代码注释上述的printclass_name.reverse()print(class_name)

如果用到这个方法，你就得这么写了，不然打印出来就会是空值。

取值

取值是根据下标来取值的，从列表的第一个字符串开始，第一个字符串下标是0：

list_number = ['cat','dog','snake','elephant']print(list_number[0])print(list_number[1])print(list_number[2])#其对应的值是：#cat#dog#snake

负数取值

list_number = ['cat','dog','snake','elephant']print(list_number[-1])print(list_number[-2])print(list_number[-3])#其对应的值是：#elephant#snake#dog

范围取值

list_number = ['cat','dog','snake','elephant']print(list_number[:3])print(list_number[1:3])print(list_number[1:])print(list_number[:-1])# 其对应的结果是：#['cat', 'dog', 'snake']#['dog', 'snake']#['dog', 'snake', 'elephant']#['cat', 'dog', 'snake']

列表长度

list_number = ['cat','dog','snake','elephant']print(len(list_number))#其结果是：#4

下标改值

list_number = ['cat','dog','snake','elephant']list_number[1] = 'nono'print(list_number)#    其结果是：#['cat', 'nono', 'snake', 'elephant']

连接与复制

list_number = ['cat','dog','snake','elephant']list_1 = ['tom','tim']print(list_number+list_1)#    其结果是：#['cat', 'dog', 'snake', 'elephant', 'tom', 'tim']#复制list_1 = ['tom','tim']print(list_1*3)#    其结果是：#['tom', 'tim', 'tom', 'tim', 'tom', 'tim']

循环列表

list_number = ['cat','dog','snake','elephant']for i in list_number:    print(i)#    其结果是：# cat# dog# snake# elephant

in和not in操作

用于判断列表中是否存在一个值

list_number = ['cat','dog','snake','elephant']print('cat' in list_number)    #Tprint('cat' not in list_number)    #F

列表操作

查找

#返回值的下标，如果重复值，只会返回第一次的值list_number = ['cat','dog','snake','elephant']print(list_number.index('dog'))

添加

# 可以指定添加到某个位置list_number = ['cat','dog','snake','elephant']list_number.insert(1,'monkey')print(list_number)#  其结果是：#  ['cat', 'monkey', 'dog', 'snake', 'elephant']

# 只能添加到末尾的位置list_number = ['cat','dog','snake','elephant']list_number.append('monkey')print(list_number)# 其结果是：# ['cat', 'dog', 'snake', 'elephant', 'monkey']

删除

list_number = ['cat','dog','snake','elephant']list_number.remove('cat')print(list_number)# 其结果是：# ['dog', 'snake', 'elephant']

list_number = ['cat','dog','snake','elephant']del list_number[1]print(list_number)# 其结果是：# ['cat', 'snake', 'elephant']

排序

升序

# 按字母顺序进行排序list_number = ['c','d','s','a']# 默认是升序list_number.sort()print(list_number)# 其结果是：# ['a', 'c', 'd', 's']# 如果想要降序list_number.sort(reverse=True)

降序

list_number = ['c','d','s','a']list_number.sort(reverse=True)

class_name = [9,3,4,6]a = sorted(class_name,reverse=True)print(a)# [9, 6, 4, 3]

倒序

也可称之为逆序

#第一种list_number = ['c','d','s','a']list_number.reverse()print(list_number)# 其结果是：# ['a', 's', 'd', 'c']#第二种class_name = ["python", "bird", "c", "app"]print(sorted(class_name))# 再次打印验证是否是临时修改print(class_name)# ['app', 'bird', 'c', 'python']# ['python', 'bird', 'c', 'app']

当然第二种可以用于创建一个新的列表：

class_name = ["python", "bird", "c", "app"]print(id(class_name))class_name = sorted(class_name)print(id(class_name))# 2781239629440# 2781239597888

注意这两内存地址不一样，所以在sorted后，class_name就是一个新的列表了。

reversed

对于倒叙还有第三种写法，但是这里为什么要单独说明呢。因为reversed返回的是一个迭代器，且reversed不对原列表做任何修改。只能用一次。再次对其print的时候就是个空列表了。

class_name = [9,3,4,6]a= reversed(class_name)print(a)print(list(a))# <list_reverseiterator object at 0x000001D6B94FEB80># [6, 4, 3, 9]# []

随机排序

import randoma = [7,2,3,5]random.shuffle(a)print(a)

每一次输出的排序会不一样。

拼接

list_number = ['c','d','s','a']list_1 = ['托马']list_number.extend(list_1)print(list_number)# 其结果是：# ['c', 'd', 's', 'a', '托马']

弹出

list_number = ['c','d','s','a']list_1 = []n = list_number.pop(1)print(list_number)list_1.append(n)print(list_1)# 其结果是：# ['c', 's', 'a']# ['d']

指定弹出索引位置的值，我们还可以进行调用哦。

结合字符串操作

list_number = ['tom','luci','xifa','BOB']for i in list_number:    print(i.upper())# 其结果是：# TOM# LUCI# XIFA# BOB

这里只举出了全部大写的例子，结合字符串所学，写法一致！

循环

# 定义一个列表name_study = ['chinese','english','math','pe']# 使用for循环,定义一个变量循环列表for i_name in name_study:#打印我们的循环结果    print(i_name)

这里这个i_name是新定义的一个变量，用于获取name_study里面的值。

# 结果chineseenglishmathpe

统计

num = [20, 30, 50, 80, 40, 10]print(min(num))    # 最小的一个数print(max(num))    # 最大的一个数print(sum(num))    # 列表的数字和

切片

切片呢，是在列表中我们可以使用索引值来处理它的一部分元素，就不需要一个一个再打印了，对于这种python中称之为切片，看例子：

# 创建一个列表num = ['python', 'java', 'c', 'php', 'html', 'c++']# 利用索引值来完成切片print(num[0:3])

这里的[0:3]，0是起始索引位置，3是终止索引位置，3的位置是终止位置不取，其结果是：

['python', 'java', 'c']

这就是切片，小伙伴明白了吗，能够使用索引值来处理列表的部分元素的操作就是切片哦！！！

切片还有很多的操作哦，看接下来的介绍：

写法：

num[start, end, step] start：开始切片的位置(包含) end：结束切片的位置(不包含) step：间隔数据个数

上面我们讲的是顺序切片，这回我们讲倒叙切片：

num = ['python', 'java', 'c', 'php', 'html', 'c++']print(num[-2:])

例子解释：倒叙，按循序切片，从倒数第二个开始往后取值，其结果是：

['html', 'c++']

间隔位置切片：

num = ['python', 'java', 'c', 'php', 'html', 'c++']print(num[1::2])

例子解释：间隔位置切片,从索引位置1开始取值，途中每隔两个取一个当前值

列表旋转：

num = ['python', 'java', 'c', 'php', 'html', 'c++']print(num[::-1])

例子解释：顾名思义就是将列表旋转倒过来打印出来，前面讲过的倒叙，这里是另一种方法。其结果是：

['c++', 'html', 'php', 'c', 'java', 'python']

接下来就是我么的一个小实战：

num = ['python', 'java', 'c', 'php', 'html', 'c++']print(num[4:1:-1])

** 在这里，可以举一反三的去思考思考，自己也可以举例然后使用切片去将列表中想要打印的元素打印出来**！

解释：因为列表的操作，-1将列表旋转，然后从索引值1的位置开始取值，到索引值4的位置，但是4不取，因为4的位置是终止位置。

接下来我们就开始进入下一个实用例子，遍历切片:

num = ['python', 'java', 'c', 'php', 'html', 'c++']for num_first in num[:3]:    print(num_first)

遍历切片，其实就是使用for循环去循环我们想要打印列表中的部分元素哦。num[:3]就是前三个元素，然后我们定义一个变量num_first，去循环前三个元素，最后打印我们定义的变量。

遍历切片，不懂的小伙伴也可以理解为循环想要输出的元素。

上述例子看不明白的看看下面这个例子，清安将上面的多定义了一个变量，便于小伙伴理解怎么回事哦！

num = ['python', 'java', 'c', 'php', 'html', 'c++']# 定义一个变量，接受我们想要输出的部分元素，也是就切片部分num_list = num[:3]for num_first in num_list:    print(num_first)

复制一个列表：

创建一个始于第一个元素，终于最后一个元素的切片，就是我们想要复制的列表，即副本

num = ['python', 'java', 'c', 'php', 'html', 'c++']number = num[:]print(number)

我们先定义一个变量使其等于已经定义的num列表切片，这个切片的写法就是num[:]，然后我们输出number变量，就可以看到原列表的副本啦，就是我们所要的复制列表！！！

二维列表

学习了上面的内容，这里就直接看例题吧，俗称列表嵌套列表：

a = [['清安','有个小屋'],['里面的人很可爱']]print(a[0][0])# 清安

这里可能取值有点迷惑，作一下解释，第一个a[0]取值列表中第一个列表，也就是['清安','有个小屋']，a[0][0]最后的这个[0]取值是['清安','有个小屋']的列表中的索引位置0的值，也就是'清安'。

补充：

统计

a = ['qing','an','an']

便捷的赋值