Python基础——认识列表

1.序列（sequence）

1.1 基本概念

• 数据结构指计算机中数据存储的方式
• 序列是Python中最基本的一种数据结构。序列用于保存一组有序的数据，所有的数据在序列当中都有一个唯一的位置（索引）并且序列中的数据会按照添加的顺序来分配索引

1.2 序列的分类

• 可变序列（序列中的元素可以改变）：例如 列表（list）字典(dict)
• 不可变序列（序列中的元素不能改变）：例如 字符串（str）元组（tuple）

# 可变序列 list、dic
fruits = ['apple','orange','strawberry','pear']
print(fruits)               #['apple', 'orange', 'strawberry', 'pear']
print(fruits[0])            #apple
fruits[0] = 'watermelon'
print(fruits)               #['watermelon', 'orange', 'strawberry', 'pear']
# 不可变序列 str、tuple
words = 'I love my life!'
print(words)                #I love my life!
print(words[0])             #I
words[0] = 'H'              #TypeError: 'str' object does not support item assignment

2.列表（list）

• 列表是Python中的一个对象
• 列表的作用：
  • 用来保存多个有序的数据
  • 用来存储对象的对象

2.1 列表的使用

• 列表的创建：通过[]定义空列表

# 创建列表
name = []           #创建一个名为name的空列表

2.2 切片

• 切片是指从现有列表中获得一个当前列表的子列表
• 通过切片可以获得获取指定的元素
• 语法: 列表名[起始 : 结束 : 步长]
• 通过切片获取元素时,会包括起始位置的元素,不会包括结束位置的元素
• 起始位置和结束位置的索引可以不写
  • 如果省略结束位置, 则会从当前的开始位置一直截取到最后
  • 如果省略开始位置, 则会从第一个元素截取到结束的元素，但是不包括结束的元素
  • 如果开始位置和结束位置都省略, 则会从第一个元素开始截取到最后一个元素
• 步长表示每次获取元素的间隔，默认是1(可以省略不写)
• 步长不能是0,但可以是是负数，步长为正数可以理解为顺序获取，是负数时可以理解为逆序获取

# 切片
foods = ['rice','noodles','dumplings','beef','pork','chicken']
print(foods)                                                     #['rice', 'noodles', 'dumplings', 'beef', 'pork', 'chicken']
# 通过切片可以获得获取指定的元素
my_breakfast = foods[0]
print(my_breakfast)                                             #rice
my_dinner = foods[1]
print(my_dinner)                                                #noodles
# 获取多个元素  语法: 列表名[起始 : 结束 : 步长]
# 通过切片获取元素时,会包括起始位置的元素,不会包括结束位置的元素
meats = foods[3:5:1]                                             #3表示起始元素'beef',5表示结束元素'pork'
print(meats)                                                    #['beef', 'pork']
meats = foods[3:6:1]
print(meats)                                                    #['beef', 'pork', 'chicken']
# 起始位置和结束位置的索引可以不写
# 如果省略结束位置, 则会从当前的开始位置一直截取到最后
food = foods[2:]
print(food)                                                     #['dumplings', 'beef', 'pork', 'chicken']
# 如果省略开始位置, 则会从第一个元素截取到结束的元素，但是不包括结束的元素
food = foods[:5]
print(food)                                                     #['rice', 'noodles', 'dumplings', 'beef', 'pork']
# 如果开始位置和结束位置都省略, 则会从第一个元素开始截取到最后一个元素
food = foods[:]
print(food)                                                     #['rice', 'noodles', 'dumplings', 'beef', 'pork', 'chicken']
# 步长不能是0,但可以是是负数
food = foods[::1]                                              
print(food)                                                     #['rice', 'noodles', 'dumplings', 'beef', 'pork', 'chicken']
food = foods[::-1]
print(food)                                                     #['chicken', 'pork', 'beef', 'dumplings', 'noodles', 'rice']
food = foods[1:5:0]                                             #ValueError: slice step cannot be zero

3.通用操作

操作符号或函数	功能
+	将两个列表拼接成一个列表
*	可以将列表重复指定的次数 （注意2个列表不能够做乘法，要和整数做乘法运算）
in	用来检查指定元素是否在列表当中
not in	用来检查指定元素是否不在列表当中
len()	获取列表中元素的个数
max()	获取列表中最大值
min()	获取列表中最小值
list.index(x[, start[, end]])	获取指定元素在列表中出现第一次的位置（参数1：需要指定的元素；参数2：查找的起始位置；参数3：查找的结束位置）
list.count(x)	统计指定元素在列表中出现的个数

# 通用操作
# + :将两个列表拼接成一个列表
num1 = [1,3,5,7,9]
num2 = [0,2,4,6,8]
num = num1 + num2
print(num)                                              #[1, 3, 5, 7, 9, 0, 2, 4, 6, 8]
# * :可以将列表重复指定的次数
words =['work','money']
my_words = words * 3
print(my_words)                                         #['work', 'money', 'work', 'money', 'work', 'money']
# in :用来检查指定元素是否在列表当中
# not in :用来检查指定元素是否不在列表当中
life = ['happiness','sadness','suffering','loneliness']
result = 'happiness' in life
print(result)                                           #True
result = 'relaxation' not in life
print(result)                                           #True
# len() :获取列表中元素的个数
# max() :获取列表中最大值
# min() :获取列表中最小值
num = [1,23,76,42,5,-9,88,42,63,42,42]
print(len(num))                                         #11
print(max(num))                                         #88
print(min(num))                                         #-9
# list.index(x[, start[, end]]) :获取指定元素在列表中出现第一次的位置
place = num.index(42)
print(place)                                            #3
place = num.index(42,4,10)
print(place)                                            #7
# list.count(x) :统计指定元素在列表中出现的个数
times = num.count(42)
print(times)                                            #4

4.修改列表

• 通过切片来修改(起始就是给切片的内容重新赋值，但是赋值的内容必须是一个序列)
• 当设置了步长时,序列中元素的个数必须和切片中元素的个数保持一致
• 通过切片来删除元素
  • del list[起始 : 结束]
  • list = []

# 修改列表
road = ['barrier','failure',' barrier','failure', 'barrier','success']
print(road)                                                             #['barrier', 'failure', ' barrier', 'failure', 'barrier', 'success']
# 通过切片来修改
road[3] = 'success'                                                     #['barrier', 'failure', ' barrier', 'success', 'barrier', 'success']
print(road)
road[0:5] = ['barrier','barrier','barrier','barrier']
##  注意：上面进行的切片赋值两边的元素个数是不同的，即可以将一段整体赋值
print(road)                                                             #['barrier', 'barrier', 'barrier', 'barrier', 'success']
# 当设置了步长时,序列中元素的个数必须和切片中元素的个数保持一致
print(road[0:5:2])                                                      #['barrier', 'barrier', 'success']
road[0:5:2] = ['barrier','failure']
print(road)                                                             #ValueError: attempt to assign sequence of size 2 to extended slice of size 3

5.列表的方法

方法	功能
append()	向列表的最后添加一个元素
insert(arg1,arg2)	向列表指定位置插入一个元素 参数1:要插入的位置 参数2:要插入的元素
extend(iterable)	使用一个新的序列来扩展当前序列(它会将该序列的中元素添加到列表中) 参数需要传递一个序列
pop()	根据索引删除并返回指定元素
remove()	删除指定元素 (如果相同值的元素有多个，只会删除第一个)
reverse()	翻转列表
sort(key=None,reverse=False)	用来对列表中的元素进行排序 reverse：True反序；False 正序

# 列表的方法
life = ['happiness','sadness','suffering','loneliness']
print(life)                                             #['happiness', 'sadness', 'suffering', 'loneliness']
# append() :向列表的最后添加一个元素
life.append('rage')
print(life)                                             #['happiness', 'sadness', 'suffering', 'loneliness', 'rage']
# insert(arg1,arg2) :向列表指定位置插入一个元素  参数1:要插入的位置 参数2:要插入的元素
life.insert(0,'emotion:')
print(life)                                             #['emotion:', 'happiness', 'sadness', 'suffering', 'loneliness', 'rage']
# extend(iterable) :使用一个新的序列来扩展当前序列(它会将该序列的中元素添加到列表中) 参数需要传递一个序列
life.extend([2,2,3])
print(life)                                             #['emotion:', 'happiness', 'sadness', 'suffering', 'loneliness', 'rage', 2, 2, 3]
# pop() :根据索引删除并返回指定元素
num = life.pop()
print(num)                                              #3
print(life)                                             #['emotion:', 'happiness', 'sadness', 'suffering', 'loneliness', 'rage', 2, 2]
# remove() :删除指定元素 (如果相同值的元素有多个，只会删除第一个)
life.remove(2)
print(life)                                             #['emotion:', 'happiness', 'sadness', 'suffering', 'loneliness', 'rage', 2]
# reverse() :翻转列表
life.reverse()
print(life)                                             #[2, 'rage', 'loneliness', 'suffering', 'sadness', 'happiness', 'emotion:']
# sort(key=None,reverse=False) :用来对列表中的元素进行排序 reverse：True反序；False 正序
num = [2,1,6,10,5,8,7]
num.sort(reverse=True)
print(num)                                              #[10, 8, 7, 6, 5, 2, 1]

6.遍历列表

6.1 for循环

• 通过for循环来遍历列表
• 语法：
  • for 变量 in 序列：
      代码块
• 注意: for循环的代码块会执行多次,序列中有几个元素就会执行几次。每执行一次就会将序列中的一个元素赋值给变量,所以我们可以通过变量来获取列表中的元素

# for循环
nums = [99,52,63,10,18,75]
for num in nums:
    print(num)
# 99
# 52
# 63
# 10
# 18
# 75

6.2 range(start, stop[, step])

参数说明

• start: 计数从 start 开始。默认是从 0 开始。例如range(6)等价于range(0,6);
• stop: 计数到 stop 结束，但不包括 stop。例如：range(0,5)是[0, 1, 2, 3, 4]没有5
• step：步长，默认为1。例如：range(0,7)等价于 range(0, 7, 1)

# range(start, stop[, step])
nums = range(5)
for num in nums:
    print(num)
# 0
# 1
# 2
# 3
# 4
nums = range(1,10)
for num in nums:
    print(num)
# 1
# 2
# 3
# 4
# 5
# 6
# 7
# 8
# 9
nums = range(1,10,3)
for num in nums:
    print(num)
# 1
# 4
# 7

小试牛刀

了解完了列表的相关基础操作，让我们试题来加深理解吧！

• 现在有 a = [1,2,3,4,5,6] 不通过函数的形式实现列表的反转([6,5,4,3,2,1]) 并写出推导过程

# 现在有 a = [1,2,3,4,5,6] 不通过函数的形式实现列表的反转([6,5,4,3,2,1]) 并写出推导过程
# 1.通过步长实现
# 要实现列表反转，可以通过设置步长为-1，从而使列表访问顺序变为逆序，再将该序列的列表赋值给原列表即可
a = [1,2,3,4,5,6]
print(a)                                    #[1, 2, 3, 4, 5, 6]
a = a[::-1]
print(a)                                    #[6, 5, 4, 3, 2, 1]
# 2.通过排序方法实现
# 考虑到列表元素全为数字，且是有规律的顺序排列，可以通过数字间的大小进行反转
a = [1,2,3,4,5,6]
#a.sort(reverse=True)
a.reverse()
print(a)
# 3.可以通过方法pop()和append()实现
# pop()是能将末尾的元素弹出，而append()能添加元素，只要将弹出的元素添加到新列表中，再将列表赋值给原列表即可
a = [1,2,3,4,5,6]
b = []
print('操作前：')
print('a:',a)                               #a: [1, 2, 3, 4, 5, 6]
print('b:',b)                               #b: []
while len(a) != 0:
    b.append(a.pop())
else:
    print('操作后：')
    print('a:',a)                           #a: []
    print('b:',b)                           #b: [6, 5, 4, 3, 2, 1]
a = b
print('反转后的a:',a)                       #反转后的a: [6, 5, 4, 3, 2, 1]

当然，实现这道题的方法远远不只上面的三种，欢迎大家踊跃给出自己的办法！