Python快速上手系列--列表--详解篇

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

列表

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

# 这里声明一个变量，后续便于输出
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])  # 索引输出python
print(class_name[1])  # 索引输出java
print(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" # 定义一个变量接受赋值，指定删除java
class_name.remove(class_remove) # 删除列表中的值，因为前面我们已经指定的删除谁
print(f"I like {class_remove.title()}")

# reverse\(\)方法

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

a = [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里面的值。

# 结果
chinese
english
math
pe

统计

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']

便捷的赋值