Python序列类型

目录

目标

版本

官方文档

序列分类

对比

list（列表）

创建

循环

常用方法

切片

tuple（元组）

创建

循环 

常用方法

切片

range（范围）

创建

循环

常用方法

切片

优势

---

目标

        掌握Python序列类型（list、tuple、range）的常用方法（创建、循环、查询、删除、切片等）。

---

版本

        Python 3.12.0

---

官方文档

Sequence Types — list, tuple, rangehttps://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range

---

序列分类

定义

        在Python中，序列是一种基本的数据类型，用于表示有序的元素集合。序列中的每个元素都有一个唯一的索引，从0开始递增。

官方定义

Sequence Types — list, tuple, range

There are three basic sequence types: lists, tuples, and range objects. Additional sequence types tailored for processing of binary data and text strings are described in dedicated sections.

译文

        有三种基本序列（实际上字符串也是序列类型，但是字符串有很多自己特有的方法。所以官方可能为了文档排版，没有将字符串写入到序列类型板块。），分别是：

1. list（列表）
2. tuple（元组）
3. range（范围）

---

对比

特性	列表 (List)	元组 (Tuple)	范围 (Range)
是否可变	可变	不可变	不可变
表达方式	[1,2,3]	(1,2,3)、(1,)	range(start,stop,step)
Java 类似对象	ArrayList	无	无
主要用途	存储可变序列	存储不可变序列	表示数字范围
索引和切片	可以通过索引和切片访问和修改元素	可以通过索引访问元素，但不可修改	可以通过索引访问元素，但不可修改
适用场景	当需要频繁修改序列时使用	当希望创建不可变的序列时使用	当表示数字范围时使用

---

list（列表）

创建

方法一（直接创建）

#直接创建
allList=["Tom",True,False,3.14,500]
#输出：['Tom', True, False, 3.14, 500]
print(allList)

方法二（通过迭代对象，使用构造方法创建。）

先来看一下官方文档对list构造方法的描述：

def __init__(self, seq=()): # known special case of list.__init__
    """
    Built-in mutable sequence.
    
    If no argument is given, the constructor creates a new empty list.
    The argument must be an iterable if specified.
    # (copied from class doc)
    """
    pass

翻译

1. list构造方法有一个参数，默认这个参数是空的元组，即表示不填写参数将默认创建一个空列表。
2. 该参数必须是可迭代的，比如：list、tuple、string、set、dictionary、文件对象、迭代器对象。

案例

#参数是字符串
myList=list("I LOVE YOU.")
#输出：['I', ' ', 'L', 'O', 'V', 'E', ' ', 'Y', 'O', 'U', '.']
print(myList)

#参数是元组
myList=list((1,2,'a',True))
#输出：[1, 2, 'a', True]
print(myList)

#参数是列表
myList=list([1,2,'a',True])
#输出：[1, 2, 'a', True]
print(myList)

#参数是集合
myList=list({2,'a',True,False,"1",0})
#输出：[False, True, 2, '1', 'a']
#注意：集合中的元素不能重复，True和False分别会被看成是1和0，所以0没有被输出。
print(myList)

#参数是字典
dic={"name":"Tome","age":13,"sex":True}
myList=list(dic.keys())
#输出：['name', 'age', 'sex'] ['Tome', 13, True]
print(list(dic.keys()),list(dic.values()))

方法三（根据文件对象创建列表）

#我桌面有个a.txt文件
with open('C://Users//20203//Desktop//a.txt', 'r') as file:
    myList = file.readlines()
#输出：['1\n', '2\n', '3\n', '4\n', '5\n', 'False\n', 'True\n', '2.13\n', 'Tom']
print(myList)

#去掉\n
with open('C://Users//20203//Desktop//a.txt', 'r') as file:
    myList = [line.strip() for line in file.readlines()]
print(myList)

方法四（根据迭代器对象创建列表）

#创建一个迭代器对象
myIterator = iter([1, False, True, "Tom", 5])
myList = list(myIterator)
#输出：[1, False, True, 'Tom', 5]
print(myList)

yourIterator = iter([1, False, True, "Tom", 5])
#使用列表推导式创建列表
yourList = [x for x in yourIterator]
#输出：[1, False, True, 'Tom', 5]
print(yourList)

---

循环

方法一（for循环）

myList = ["Tom", "Jack", 3.14, True]
for item in myList:
    print(item)

方法二（enumerate() 函数）

myList = ["Tom", "Jack", 3.14, True]
for index,value in enumerate(myList):
    print(f"下标={index}；值={value}")

方法三（while循环）

myList = ["Tom", "Jack", 3.14, True]
index=0
while index

方法四（迭代器遍历）

myList = ["Tom", "Jack", 3.14, True]
myIter = iter(myList)
#输出：
print(type(myIter))
while True:
    try:
        print(next(myIter))
    except StopIteration:
        #结束循环
        break;

---

常用方法

在列表末尾添加元素

myList = ["Tom", "Jack", 3.14, True]
myList.append("Cat")

将可迭代对象中的元素依次添加到列表中

myList = ["Tom", "Jack", 3.14, True]
#这里以set为例
myList.extend({"23","a"})
#输出：['Tom', 'Jack', 3.14, True, '23', 'a']
print(myList)

将元素插入到指定的下标位置

myList = ["Tom", "Jack", 3.14, True]
#把love插入到下标为2的位置
myList.insert(2,"love")
#输出：['Tom', 'Jack', 'love', 3.14, True]
print(myList)

移除列表中第一个元素值=value的元素

myList = ["Tom", "Jack", 3.14, True,"Jack",False]
myList.remove("Jack")
#输出：['Tom', 3.14, True, 'Jack', False]
print(myList)

移除列表中的元素并返回元素（默认移除最后一个元素）

myList = ["Tom", "Jack", 3.14, True,"Jack",False]
item=myList.pop(2)
#输出：['Tom', 'Jack', True, 'Jack', False]
print(myList)
#输出：3.14
print(item)


nameList = ["Tom", "Jack"]
#默认移除最后一个元素
name=nameList.pop()
#输出：['Tom']
print(nameList)
#输出：Jack
print(name)

移除所有元素

myList = ["Tom", "Jack", 3.14, True,"Jack",False]
myList.clear()
#输出：[]
print(myList)

返回第一个值为value的索引，可以设定范围。

myList = ["Tom", "Jack", 3.14, True,"Jack",False]
item=myList.index("Jack")
#输出：1
print(item)

item=myList.index("Jack",1)
#输出：1
print(item)

item=myList.index("Jack",2)
#输出：4
print(item)

item=myList.index("Jack",4,5)
#输出：4
print(item)

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

myList = ["Tom", "Jack", 3.14, True,"Jack",False]
count=myList.count("Jack")
#输出：2
print(count)

排序

升序排序

numList=[6,2,1,5,4,3]
numList.sort()
#输出：[1, 2, 3, 4, 5, 6]
#分析：默认升序排序
print(numList)

降序排序

numList=[6,2,1,5,4,3]
#分析：设置降序排序
numList.sort(reverse=True)
#输出：[6, 5, 4, 3, 2, 1]
print(numList)

区分字母大小写排序

fruitList = ['apple', 'Banana', 'orange', 'Grapes', "Strawberry", "Cherry", "Peach", "Mango", "Watermelon"]
#输出：['Banana', 'Cherry', 'Grapes', 'Mango', 'Peach', 'Strawberry', 'Watermelon', 'apple', 'orange']
#分析：'apple', 'orange'排在后面，是因为这两个元素以小写开头。
fruitList.sort()
print(fruitList)

不区分字母大小写排序

fruitList = ['apple', 'Banana', 'orange', 'Grapes', "Strawberry", "Cherry", "Peach", "Mango", "Watermelon"]

#设置列表中的字符串按照小写形式进行比较，实现对字符串的不区分大小写排序。
fruitList.sort(key=str.lower)
#输出：['apple', 'Banana', 'Cherry', 'Grapes', 'Mango', 'orange', 'Peach', 'Strawberry', 'Watermelon']
print(fruitList)

#设置列表中的字符串按照小写形式进行比较，实现对字符串的不区分大小写排序。并且降序排序。
fruitList.sort(key=str.lower,reverse=True)
#输出：['Watermelon', 'Strawberry', 'Peach', 'orange', 'Mango', 'Grapes', 'Cherry', 'Banana', 'apple']
print(fruitList)

自定义排序

myList = ["王五", None, "张三", "李四", "赵六"]
#这里定义一个字典，来设置排序规则，指定元素的顺序。
order = {"张三": 0, "李四": 1, "王五": 2, "赵六": 3}

#分析：lambda函数的作用是，当列表中的元素x在字典 order 中存在时，返回对应的值（指定的顺序），如果x在字典中不存在，则返回正无穷大。
myList.sort(key=lambda x: order.get(x, float('inf')))
#输出：['张三', '李四', '王五', '赵六', None]
print(myList)

#使用自定义排序规则进行反向排序
myList.sort(key=lambda x: order.get(x, float('inf')),reverse=True)
#输出：[None, '赵六', '王五', '李四', '张三']
print(myList)

反转元素

myList = ["王五", None, "张三", "李四", "赵六"]
myList.reverse()
#输出：['赵六', '李四', '张三', None, '王五']
print(myList)

浅拷贝

列表浅拷贝会创建新的列表对象，但是新的列表中的元素引用了旧的列表中的元素。所以说，浅拷贝创建的对象不是一个完全独立的副本。特别注意：如果旧列表中的元素是不可变对象（如整数、字符串等）则修改旧列表元素的值，新列表不会有变化。反之，如果则新列表会跟随变化。

myList = ["王五", None, "张三", "李四", "赵六"]
yourList=myList.copy()
#输出：['王五', None, '张三', '李四', '赵六']
print(yourList)
#输出两个不同的id
print(id(myList),id(yourList))
#输出相同的id
print(id(myList[0]),id(yourList[0]))

myList[0]="钱七"
print(myList)
print(yourList)
#输出不相同的id
print(id(myList[0]),id(yourList[0]))

otherList=[[1,2,3],[4,5,6]]
copyOtherList=otherList.copy()
otherList[0][0]=9
#输出：[[9, 2, 3], [4, 5, 6]]
print(otherList)
#输出：[[9, 2, 3], [4, 5, 6]]
print(copyOtherList)

深拷贝

深拷贝创建的对象是一个完全独立的副本。这里不做测试，如果大家想测试的话，可以按照上述浅拷贝的方法去测试。

import copy

myList = ["王五", None, "张三", "李四", "赵六"]
yourList = copy.deepcopy(myList)
print(yourList)

---

切片

即从原来的列表获取子列表。格式为：list[start:stop:step]。start表示切片起始索引，默认为0。stop表示切片结束索引（不包含stop），默认为len(list)。step表示步长，默认步长为1。步长可以为负整数（表示反向切片），但不能为0。如果start>=stop，则返回空集合。

用法案例

myList = [0,1,2,3,4,5,6,7,8,9]
yourList = myList[2:5]
#输出：[2, 3, 4]
print(yourList)

yourList = myList[2:8:2]
#输出：[2, 4, 6]
print(yourList)

#等同于：myList[2::]
yourList = myList[2:]
#输出：[2, 3, 4, 5, 6, 7, 8, 9]
print(yourList)

yourList = myList[:2:]
#输出：[0, 1]
print(yourList)

yourList = myList[::3]
#输出：[0, 3, 6, 9]
print(yourList)

yourList = myList[::]
#输出：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(yourList)

yourList = myList[::]
#输出：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(yourList)

yourList = myList[-2:-1:]
#输出：[8]
#分析：-2表示从倒数第二个元素开始，-1表示一直到最后个元素截止（不包含最后一个元素）。
print(yourList)

yourList = myList[::-1]
#输出：[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
#分析：步长为负数表示反向步长切片。
print(yourList)

使用场景

（1）复制列表

以下案例证明了通过切片复制来的列表是浅拷贝模式。参考上述我对浅拷贝的描述。

myList = ["王五", None, "张三", "李四", "赵六"]
#等同于：myList[::]
yourList=myList[:]
#输出：['王五', None, '张三', '李四', '赵六']
print(yourList)
#输出两个不同的id
print(id(myList),id(yourList))
#输出相同的id
print(id(myList[0]),id(yourList[0]))

myList[0]="钱七"
print(myList)
print(yourList)
#输出不相同的id
print(id(myList[0]),id(yourList[0]))

otherList=[[1,2,3],[4,5,6]]
copyOtherList=otherList.copy()
otherList[0][0]=9
#输出：[[9, 2, 3], [4, 5, 6]]
print(otherList)
#输出：[[9, 2, 3], [4, 5, 6]]
print(copyOtherList)

---

tuple（元组）

（1）官方描述

Tuples are immutable sequences, typically used to store collections of heterogeneous data (such as the 2-tuples produced by the enumerate() built-in). Tuples are also used for cases where an immutable sequence of homogeneous data is needed (such as allowing storage in a set or dict instance).

译文

1. 元组是不可变序列。
2. 元组的元素可以是不同类型。

（2）官方描述（重点）

Using a trailing comma for a singleton tuple: a, or (a,)

译文

只有一个元素的元组，这个元素后面要加逗号。演示案例如下：

a=(8)
b=(8,)
#输出：
print(type(a))
#输出：
print(type(b))

a=("Hello World.")
b=("Hello World.",)
#输出：
print(type(a))
#输出：
print(type(b))

---

创建

方法一（直接创建）

myTuple=(1,2,3,True,2,"Hello World!")
#输出：(1, 2, 3, True, 2, 'Hello World!')
print(myTuple)

方法二（通过迭代对象，使用构造方法创建。）

#参数是字符串
myTuple=tuple("I LOVE YOU.")
#输出：('I', ' ', 'L', 'O', 'V', 'E', ' ', 'Y', 'O', 'U', '.')
print(myTuple)

#参数是元组
myTuple=tuple((1,2,'a',True))
#输出：(1, 2, 'a', True)
print(myTuple)

#参数是列表
myTuple=tuple([1,2,'a',True])
#输出：(1, 2, 'a', True)
print(myTuple)

#参数是集合
myTuple=tuple({2,'a',True,False,"1",0})
#输出：(False, True, 2, '1', 'a')
#注意：集合中的元素不能重复，True和False分别会被看成是1和0，所以0没有被输出。
print(myTuple)

#参数是字典
dic={"name":"Tome","age":13,"sex":True}
myTuple=tuple(dic.keys())
#输出：('name', 'age', 'sex') ('Tome', 13, True)
print(tuple(dic.keys()),tuple(dic.values()))

方法三（根据文件对象创建元组）

#我桌面有个a.txt文件
with open('C://Users//20203//Desktop//a.txt', 'r') as file:
    myTuple = tuple(file)
#输出：('1\n', '2\n', '3\n', '4\n', '5\n', 'False\n', 'True\n', '2.13\n', 'Tom')
print(myTuple)

#去掉\n
with open('C://Users//20203//Desktop//a.txt', 'r') as file:
    myList = tuple(line.strip() for line in file.readlines())
#输出：('1', '2', '3', '4', '5', 'False', 'True', '2.13', 'Tom')
print(myList)

方法四（根据迭代器对象创建元组）

#创建一个迭代器对象
myIterator = iter([1, False, True, "Tom", 5])
myTuple = tuple(myIterator)
#输出：(1, False, True, 'Tom', 5)
print(myTuple)

yourIterator = iter([1, False, True, "Tom", 5])
#使用列表推导式创建列表
yourTuple = tuple(x for x in yourIterator)
#输出：(1, False, True, 'Tom', 5)
print(yourTuple)

循环 

方法一（for循环）

myTuple = ("Tom", "Jack", 3.14, True)
for item in myTuple:
    print(item)

方法二（enumerate() 函数）

myTuple= ("Tom", "Jack", 3.14, True)
for index,value in enumerate(myTuple):
    print(f"下标={index}；值={value}")

方法三（while循环）

myTuple= ("Tom", "Jack", 3.14, True)
index=0
while index

方法四（迭代器遍历）

myTuple = ("Tom", "Jack", 3.14, True)
myIter = iter(myTuple)
#输出：
print(type(myIter))
while True:
    try:
        print(next(myIter))
    except StopIteration:
        #结束循环
        break;

常用方法

返回第一个值为value的索引，可以设定范围。

myTuple = ("Tom", "Jack", 3.14, True,"Jack",False)
item=myTuple.index("Jack")
#输出：1
print(item)

item=myTuple.index("Jack",1)
#输出：1
print(item)

item=myTuple.index("Jack",2)
#输出：4
print(item)

item=myTuple.index("Jack",4,5)
#输出：4
print(item)

统计某元素在元组中出现的次数

myTuple = ("Tom", "Jack", 3.14, True,"Jack",False)
count=myTuple.count("Jack")
#输出：2
print(count)

浅拷贝

注意：虽然我使用copy模块的deepcopy方法，但是两个元组和两个元组同下标的元素都指向相同索引，也就是说元组和元素都没有创建新的副本。如果元组中的元素有可变的对象，则使用copy模块的deepcopy方法，元组和元素才会创建新的副本，案例在深拷贝栏目下见。

myTuple=("a",1,2,3,False)
yourTuple=myTuple[:]
#输出：相同的id
print(id(yourTuple),id(myTuple))
#输出：相同的id
print(id(yourTuple[0]),id(myTuple[0]))

import copy

myTuple= ("王五", None, "张三", "李四", "赵六")
yourTuple = copy.deepcopy(myTuple)
#输出：返回相同的id
print(id(yourTuple),id(myTuple))
#输出：返回相同的id
print(id(yourTuple[0]),id(myTuple[0]))

深拷贝

import copy

myTuple= ([1,2,3], None, "张三", "李四", "赵六")
yourTuple = copy.deepcopy(myTuple)
#输出：不相同的id
print(id(yourTuple),id(myTuple))
#输出：不相同的id
print(id(yourTuple[0]),id(myTuple[0]))

yourTuple[0][1]="aaa"
#输出：([1, 2, 3], None, '张三', '李四', '赵六')
print(myTuple)
#输出：([1, 'aaa', 3], None, '张三', '李四', '赵六')
print(yourTuple)

切片

myTuple = (0,1,2,3,4,5,6,7,8,9)
yourTuple = myTuple[2:5]
#输出：(2, 3, 4)
print(yourTuple)

yourTuple = myTuple[2:8:2]
#输出：(2, 4, 6)
print(yourTuple)

#等同于：myTuple[2::]
yourTuple = myTuple[2:]
#输出：(2, 3, 4, 5, 6, 7, 8, 9)
print(yourTuple)

yourTuple = myTuple[:2:]
#输出：(0, 1)
print(yourTuple)

yourTuple = myTuple[::3]
#输出：(0, 3, 6, 9)
print(yourTuple)

yourTuple = myTuple[::]
#输出：(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
print(yourTuple)

yourTuple = myTuple[::]
#输出：(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
print(yourTuple)

yourTuple = myTuple[-2:-1:]
#输出：(8,)
#分析：-2表示从倒数第二个元素开始，-1表示一直到最后个元素截止（不包含最后一个元素）。
print(yourTuple)

yourTuple = myTuple[::-1]
#输出：(9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
#分析：步长为负数表示反向步长切片。
print(yourTuple)

range（范围）

官方描述

The range type represents an immutable sequence of numbers and is commonly used for looping a specific number of times in for loops.

译文

range类型表示一个不可变的数字序列，通常用于在for循环中循环特定次数。

---

创建

1. 如果start>=stop，则range对象表示的范围为空。
2. step为负数，表示倒序排列元素。

myRange=range(10);
#输出：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list(myRange))

myRange=range(2,10);
#输出：[2, 3, 4, 5, 6, 7, 8, 9]
print(list(myRange))

myRange=range(2,2,1);
#输出：[]
print(list(myRange))

myRange=range(2,10,3);
#输出：[2, 5, 8]
print(list(myRange))

myRange=range(2,-10,-1);
#输出：[2, 1, 0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
print(list(myRange))

myRange=range(2,-10,1);
#输出：[]
print(list(myRange))

---

循环

方法一（for循环）

myRange=range(10);
for value in myRange:
    print(value)

方法二（enumerate() 函数）

myRange=range(10);
for index,value in enumerate(myRange):
    print("index={},value={}".format(index,value))

 方法三（while循环）

myRange=range(10);
index=0
while index

方法四（迭代器遍历）

myRange = range(10);
myIter = iter(myRange)
while True:
    try:
        print(next(myIter))
    except StopIteration:
        break

---

常用方法

排序

注意：range是不可变序列，不可以进行排序。对range使用sorted方法实际上是创建了一个list类型的新对象。

升序

myRange = range(5, 1, -1)
sortedRange = sorted(myRange)
#输出：[5, 4, 3, 2]
print(list(myRange))
#输出：[2, 3, 4, 5]
print(list(sortedRange))

#输出： 
print(type(sortedRange),type(myRange))
#输出：不同的id
print(id(sortedRange),id(myRange))

降序

myRange = range(10)
sortedRange = sorted(myRange,reverse=True)
#输出：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list(myRange))
#输出：[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
print(list(sortedRange))

#输出： 
print(type(sortedRange),type(myRange))
#输出：不同的id
print(id(sortedRange),id(myRange))

最大值和最小值

myRange = range(10)
#输出：0
print(min(myRange))
#输出：9
print(max(myRange))

表示的元素个数

myRange = range(10)
#输出：10
print(len(myRange))

某元素是否在范围内

myRange = range(10)
#输出：True
print(2 in myRange)
#输出：False
print(20 in myRange)

---

切片

myRange = range(10)
#输出：[2, 3, 4]
print(list(myRange[2:5]))

#输出：[2, 4, 6]
print(list(myRange[2:8:2]))

#等同于：myRange[2::]
#输出：[2, 3, 4, 5, 6, 7, 8, 9]
print(list(myRange[2:]))

#输出：[0, 1]
print(list(myRange[:2:]))

#输出：[0, 3, 6, 9]
print(list(myRange[::3]))

#输出：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list(myRange[::]))

#输出：[8]
#分析：-2表示从倒数第二个元素开始，-1表示一直到最后个元素截止（不包含最后一个元素）。
print(list(myRange[-2:-1:]))

#输出：[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
#分析：步长为负数表示反向步长切片。
print(list(myRange[::-1]))

---

优势

官方描述

The advantage of the range type over a regular list or tuple is that a range object will always take the same (small) amount of memory, no matter the size of the range it represents (as it only stores the start, stop and step values, calculating individual items and subranges as needed).

Range objects implement the collections.abc.Sequence ABC, and provide features such as containment tests, element index lookup, slicing and support for negative indices (see Sequence Types — list, tuple, range):

译文

1. range相对于普通列表和元组的优势在于：range对象始终占用相同（少量）的内存空间，不受范围大小影响。
2. range对象只存储start（起始值）、stop（终止值）、step（步长）并不存储元素。
3. range对象实现了collections.abc.Sequence抽象基类（ABC），并提供一些序列类型的特性，如包含测试、元素索引查找、切片和支持负索引。

# 使用 range 对象
import sys

myRange = range(1000)
yourRange = range(2000)
#sys.getsizeof方法：获取对象的字节大小（在内存中占用的字节数）。
#sys.getsizeof 在某些情况下可能并不是百分之百准确，因为它可能不考虑由解释器或底层系统分配的一些额外开销。
# 输出:48
print(sys.getsizeof(myRange))
# 输出:48
print(sys.getsizeof(yourRange))
# 使用列表
myList = list(range(1000))
# 输出: 8056
print(sys.getsizeof(myList))