python列表元组字典都属于有序序列_python 学习（七）- 序列、列表、元组、字典、集合...

一、序列

序列是 python 中最基本的数据结构，序列中的元素都有对应的位置值，该位置值称为索引，其中序列类型包括字符串、列表、元组、集合和字典，区别在于：

1)字符串、列表、元组支持索引、切片、相加、相乘通用的操作。

2)集合和字典不支持索引、切片、相加和相乘操作。

1.1 序列索引

序列索引有两种表示形式：

1)从左向右计数，从 0 开始递增：

str = "www.baidu.com"

# print w

print(str[0])

2)从右向左计数，从 -1 开始递减：

str = "www.baidu.com"

# print m

print(str[-1])

1.2 序列切片

也可以通过切片操作来访问序列元素，而切片操作，生成的是一个新的序列，语法格式如下：

sname[start : end : step]

其中，各个参数的含义分别是：

sname：表示序列的名称。

start：表示切片的开始索引位置(包括该位置)，默认为0。

end：表示切片的结束索引位置(不包括该位置)，如果不指定，则默认为序列的长度。

step：表示在切片过程中，隔几个存储位置(包含当前位置)取一次元素。

str = "www.baidu.com"

# 从索引0开始到索引3前

# print www

print(str[:3])

# 从索引0开始到序列长度结束，每隔3个位置切一次

# print w.i.m

print(str[::3])

# 保留原字符串

# print www.baidu.com

print(str[:])

1.3 序列相加

序列相加，可以得到一个新的字符串：

str = ".com"

# print www.baidu.com

print("www." + "baidu" + str)

1.4 序列相乘

序列相乘，字符串打印的次数增加：

str = "www.baidu.com"

# print www.baidu.comwww.baidu.comwww.baidu.com

print(str * 3)

1.5 元素是否包含序列中

in 包含，not in 不包含：

str = "www.baidu.com"

# print False

print('W' in str)

# True

print('V' not in str)

除此之外，序列还包含以下相关内置函数：

函数

功能

len()

计算序列的长度，即返回序列中包含多少个元素。

max()

找出序列中的最大元素。

min()

找出序列中的最小元素。

list()

将序列转换为列表。

str()

将序列转换为字符串。

sum()

计算元素和。

sorted()

对元素进行排序。

reversed()

反向序列中的元素。

enumerate()

将序列组合为一个索引序列，多用在 for 循环中。

二、列表

列表是 python 中标准数据类型之一，可以把它看成存储数据的容器，并且可以存储不同类型的数据，列表是可更改的数据类型，意味着修改列表，在内存空间中的地址不会变。

2.1 创建

列表的创建形式有两种：

1)直接声明：

lis = [1, 2, 3, 4, 5]

# print

print(type(lis))

2)将序列转换为列表：

lis = (1, 2, 3, 4, 5)

# print

print(type(list(lis)))

2.2 增

1)由于列表也是序列的一种，因此可以通过 + 在列表的末尾插入：

lis1 = [1, 2, 3]

lis2 = [4, 5, 6]

lis = lis1 + lis2

# print [1, 2, 3, 4, 5, 6]

print(lis)

2)append() 用于在列表的末尾追加元素，这个元素可以是单个元素，也可以是列表、元组等：

lis1 = [1, 2, 3]

lis1.append(4)

# print [1, 2, 3, 4]

t = (1, 2, 3)

lis1.append(t)

# print [1, 2, 3, 4, (1, 2, 3)]

print(lis1)

3)extend() 用于在列表的末尾追加元素，它与 append() 不同之处就是不会把列表或者元祖视为一个整体，而是把它们包含的元素逐个添加到列表中。

lis1 = [1, 2, 3]

t = (1, 2, 3)

lis1.extend(t)

# print [1, 2, 3, 1, 2, 3]

print(lis1)

4)insert() 可以将元素插入到列表中指定的索引位置，当插入列表或者元祖时，insert() 也会将它们视为一个整体，作为一个元素插入到列表中，这一点和 append() 是一样的。

lis1 = [1, 2, 3]

lis1.insert(1, 4)

# print [1, 4, 2, 3]

print(lis1)

t = (7, 8, 9)

lis1.insert(2, t)

# print [1, 4, (7, 8, 9), 2, 3]

print(lis1)

2.3 删

python 列表删除元素主要分为以下 3 种场景：

根据目标元素所在位置的索引进行删除，可以使用 del 关键字或者 pop() 方法。

根据元素本身的值进行删除，可使用列表提供的 remove() 方法。

将列表中所有元素全部删除，可使用列表提供的 clear() 方法。

1)del：python 中的关键字，用来执行删除操作，它不仅可以删除整个列表，还可以删除列表中的某些元素。

lis = [1, 2, 3, 4, 5]

del lis[0]

# print [2, 3, 4, 5]

print(lis)

del lis[1:3]

# print [2, 5]

print(lis)

del lis

# NameError: name 'lis' is not defined

print(lis)

2)pop()：用来删除列表中指定索引处的元素，如果没指定索引，默认删除最后一个元素：

lis = [1, 2, 3, 4, 5]

lis.pop(0)

# print [2, 3, 4, 5]

print(lis)

lis.pop()

# print [2, 3, 4]

print(lis)

pop() 其实相当于数据结构中的出栈操作，与之对应的是 push() ，但 python 没提供 push() 方法，因为可以用 append() 来代替 push() 的功能。

3)remove()：该方法会根据元素本身的值来进行删除操作，需要注意的是，remove() 方法只会删除第一个和指定值相同的元素，而且必须保证该元素是存在的，否则会报错：

lis = [1, 2, 4, 2, 5]

lis.remove(2)

# print [1, 4, 2, 5]

print(lis)

lis.remove(3)

# ValueError: list.remove(x): x not in list

print(lis)

4)clear()：删除列表的所有元素，即清空列表：

lis = [1, 2, 4, 2, 5]

lis.clear()

# print []

print(lis)

2.4 改

python 中列表若需要修改元素方式其实很简单，只要通过下标重新赋值即可：

lis = [1, 2, 3, 4, 5]

lis[0] = 0

# print [0, 2, 3, 4, 5]

print(lis)

2.4 查

1)可以通过列表的元素的下标来对元素进行访问：

lis = [1, 2, 3, 4, 5]

# print 3

print(lis[2])

2)通过切片进行访问：

lis = [1, 2, 3, 4, 5]

# print [1, 3, 5]

print(lis[0:5:2])

三、元组

元组是 python 中另一个重要的序列结构，和列表类似，从存储内容上看，元组可以存储整数、实数、字符串、列表、元组等任何类型的数据，并且在同一个元组中，元素的类型可以不同，元组也是由一系列按特定顺序排序的元素组成它与列表的不同之处在于：

列表的元素是可以更改的，包括修改元素值，删除和插入元素，所以列表是可变序列。

元组一旦被创建，它的元素就不可更改了，所以元组是不可变序列。

3.1 创建

1)直接声明：

t = (1, 2, 3, 4)

# print

print(type(t))

3.2 删

可以通过 del 关键字将其删除：

t = (1, 2, 3, 4)

# print (1, 2, 3, 4)

print(t)

del t

# NameError: name 't' is not defined

print(t)

3.3 查

1)可以使用索引(Index)访问元组中的某个元素(得到的是一个元素的值)：

t = (1, 2, 3, 4)

# print 3

print(t[2])

2)可以使用切片访问元组中的一组元素(得到的是一个新的子元组)。

t = (1, 2, 3, 4)

# print (2, 4)

print(t[1:4:2])

四、字典

字典是一种无序可变的序列，它的元素以“键值对(key-value)”形式存储，区别于列表和元组，都是有序的序列，它们的元素在底层是挨着存放的，字典有以下特征：

1)通过键而不是索引来访问元素：字典类型是通过键把值联系起来的，这样就可以通过键从字典中获取指定项，而不是通过索引来获取。

2)字典是任意数据类型的无序集合：与列表、元组不同，通常会将索引值 0 对应的元素称为第一个元素，而字典中的元素是无序的。

3)字典是可变的，并且可以任意嵌套：字典可以在原处增长或者缩短，并且它支持任意深度的嵌套，即字典存储的值也可以是列表或其它的字典。

4)字典的键必须唯一：字典中，不支持同一个键出现多次，否则只会保留最后一个键值对。

5)字典的键不可变：字典中每个键值对的键是不可变的，只能使用数字、字符串或者元组，不能使用列表。

4.1 创建

1)通过 { } 创建：

dic = {"userName": "isKylin", "userPassword": "123456"}

# print {'userName': 'isKylin', 'userPassword': '123456'}

print(dic)

2)fromkeys() 方法创建：

subject = ['语文', '数学', '英语']

scores = dict.fromkeys(subject, 90)

# print {'语文': 90, '数学': 90, '英语': 90}

print(scores)

简单解释一下上面的代码段：首先，创建了一个学科的列表，通过字典的 fromkeys() 方法将该列表设置为一个新字典的键，后面的90表示给这个新字典的键赋值为90，这种创建方式通常用于初始化字典，设置 value 的默认值。

3)dict() 映射函数创建：

如果不为 dict() 函数传入任何参数，则代表创建一个空的字典，例如：

dic = dict()

# print {}

print(dic)

a = dict(key1='value1', key2='value2', key3='value3')

# print {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

print(a)

4.2 增

为字典添加新的键值对很简单，直接给不存在的 key 赋值即可：

dic = {"userName": "isKylin", "userPassword": "123456"}

dic["email"] = "[email protected]"

# print {'userName': 'isKylin', 'userPassword': '123456', 'email': '[email protected]'}

print(dic)

4.3 删

和删除列表、元组一样，手动删除字典也可以使用 del 关键字，例如：

dic = {"userName": "isKylin", "userPassword": "123456"}

# print {'userName': 'isKylin', 'userPassword': '123456'}

print(dic)

del dic

# NameError: name 'dic' is not defined

print(dic)

注意： python 自带垃圾回收功能，会自动销毁不用的字典，所以一般不需要通过 del 来手动删除。

4.4 改

字典中的 key 不能被修改，但是 value 可以：

dic = {"userName": "isKylin", "userPassword": "123456"}

dic["userName"] = "newIsKylin"

# print {'userName': 'newIsKylin', 'userPassword': '123456'}

print(dic)

4.5 查

与列表和元组不同的是，字典通过键值来访问：

dic = {"userName": "isKylin", "userPassword": "123456"}

# print isKylin

print(dic["userName"])

除此之外，还可以通过 get() 方法来访问：

dic = {"userName": "isKylin", "userPassword": "123456"}

# print 不存在该键值

print(dic.get("test", "不存在该键值"))

# print isKylin

print(dic.get("userName", "不存在该键值"))

除此之外，字典还包含以下相关内置方法：

方法

描述

clear()

删除字典内所有元素。

copy()

返回一个字典的浅复制。

key in dict

如果键在字典 dict 里返回 true，否则返回 false。

items()

以列表返回可遍历的(键, 值) 元组数组。

pop()

删除字典给定键 key 对应的值，返回值为被删除的值，key 必须给出，否则返回 default 值。

popitems()

随机返回并删除字典中的最后一对键和值。

五、集合

集合用来存储不重复的元素，因此集合中元素是唯一的，集合只能存储不可变的数据类型，例如整型、浮点型、字符串、元组，无法存储列表、字典、集合，python 有两种集合类型，set 集合、frozenset 集合，区别是，set 集合可以做添加、删除元素的操作，而 forzenset 集合不行。

5.1 创建

1)通过 { } 创建：

a = {1, 1, 'c', 'c', (1, 2, 3), (1, 2, 3)}

# print {1, (1, 2, 3), 'c'}

print(a)

可以看到，集合中重复的元素不见了，这体现了集合的一个特点就是元素是唯一的，不重复。

2)set() 函数创建：

set1 = set("www.baidu.com")

set2 = set([1, 1, 2, 3, 3])

# print {'.', 'b', 'i', 'd', 'w', 'c', 'o', 'u', 'a', 'm'}

print(set1)

# print {1, 2, 3}

print(set2)

注意：要创建空集合，只能用 set() 函数实现，因为使用一对 {}，python 解释器会将其视为一个空字典。

5.2 增

可以通过 set 类型提供的 add() 方法实现，需要注意的是，使用 add() 方法添加的元素，只能是数字、字符串、元组或者布尔类型(True 和 False)值，不能添加列表、字典、集合这类可变的数据，否则 python 解释器会报 TypeError 错误，例如：

a = {1, 2, 3}

a.add((1, 2))

# print {(1, 2), 1, 2, 3}

print(a)

a.add([1, 2])

# TypeError: unhashable type: 'list'

print(a)

5.3 删

和其他序列类型一样，手动函数集合类型，也可以使用 del() 语句，例如：

a = {1, 2, 3}

# print {1, 2, 3}

print(a)

del a

# NameError: name 'a' is not defined

print(a)

5.4 查

集合元素是无序的，无法像列表那样使用下标访问元素，因此需要使用循环结构，将集合中的数据逐一读取出来：

a = {1, 2, 3}

for element in a:

# print 1 2 3

print(element)

5.5 交并差集运算

集合最常做的操作就是进行交集、并集、差集以及对称差集运算：

运算符

含义

例子

交集

&

取两集合公共的元素

set1 & set2 => {3}

并集

|

取两集合全部的元素

set1 | set2 => {1,2,3,4,5}

差集

-

取一个集合中另一集合没有的元素

set1 - set2 => {1,2} | set2 - set1 => {4,5}

对称差集

^

取集合 A 和 B 中不属于 A & B 的元素

set1 ^ set2 => {1,2,4,5}

除此之外，set 集合还包含以下方法：

1)clear()：清空集合中所有元素。

s = {1, 2, 3}

# print {1, 2, 3}

print(s)

s.clear()

# print set()

print(s)

2)copy()：拷贝集合。

s = {1, 2, 3}

s1 = s.copy()

# print {1, 2, 3}

print(s1)

3)difference()：将集合 A 中有而集合 B 没有的元素给集合 C。

s1 = {1, 2, 3}

s2 = {3, 4, 5}

s3 = s1.difference(s2)

# print {1, 2}

print(s3)

4)difference_update()：从集合 A 中删除与集合 B 相同的元素。

s1 = {1, 2, 3}

s2 = {3, 4, 5}

s1.difference_update(s2)

# print {1, 2}

print(s1)

5)discard()：删除集合元素。

s1 = {1, 2, 3, 5}

s1.discard(5)

# print {1, 2, 3}

print(s1)

6)intersection()：取两个集合的交集给新集合。

s1 = {1, 2, 3}

s2 = {3, 4, 5}

s3 = s1.intersection(s2)

# print {3}

print(s3)

7)intersection_update()：取两个集合的交集，并更新给指定集合。

s1 = {1, 2, 3}

s2 = {3, 4, 5}

s1.intersection_update(s2)

# print {3}

print(s1)

8)isdisjoint()：判断两集合是否没有交集，有交集返回 False，没有交集返回 True。

s1 = {1, 2, 3}

s2 = {3, 4, 5}

# print False

print(s1.isdisjoint(s2))

9)issubset()：判断集合 A 是否是集合 B 的子集。

s1 = {1, 2, 3}

s2 = {3}

# print True

print(s2.issubset(s1))

10)issuperset()：判断集合 B 是否是集合 A 的子集。

s1 = {1, 2, 3}

s2 = {3}

# print True

print(s1.issuperset(s2))

11)pop()：取集合中一个元素，并赋值给新集合。

s1 = {1, 2, 3}

a = s1.pop()

# print 1

print(a)

# print {2, 3}

print(s1)

12)remove()：移除集合中的元素。

s1 = {4, 5, 6}

s1.remove(5)

# print {4, 6}

print(s1)

13)symmetric_difference()：取两集合中互不相同的元素，给新集合。

s1 = {4, 5, 6}

s2 = {6, 7, 8}

s3 = s1.symmetric_difference(s2)

# print {4, 5, 7, 8}

print(s3)

14)symmetric_difference_update()：取两集合中互不相同的元素，并更新给集合。

s1 = {4, 5, 6}

s2 = {6, 7, 8}

s1.symmetric_difference_update(s2)

# print {4, 5, 7, 8}

print(s1)

15)union()：取两个集合的并集，赋给新集合。

s1 = {1, 2, 3}

s2 = {3, 4, 5}

s3 = s1.union(s2)

# print {1, 2, 3, 4, 5}

print(s3)

16)update()：添加列表或集合中的元素到集合中。

s1 = {1, 2, 3}

s1.update([3, 4, 5])

# print {1, 2, 3, 4, 5}

print(s1)

5.6 frozenset 集合

frozenset 集合是不可变序列，set 集合中 remove()、discard()、add() 等方法，frozenset 都不支持，set 集合中不改变集合本身的方法，fronzenset 都支持。

那么，什么情况下使用 frozenset 集合？

当集合的元素不需要改变时，我们可以使用 fronzenset 替代 set，这样更加安全。

要求必须是不可变对象，要使用 fronzenset 替代 set，比如，字典的键就要求是不可变对象。

s = {1, 2, 3}

fs = frozenset([1, 2])

s1 = {4, 5}

# 向 s 集合中添加 fs

s.add(fs)

# print {1, 2, 3, frozenset({1, 2})}

print(s)

# 向 s 集合添加 s1 集合

s.add(s1)

# TypeError: unhashable type: 'set'

print(s)

执行上面的代码片段可以验证，set 集合本身的元素必须是不可变的， 所以 set 的元素不能是 set，只能是 frozenset，向 set 中添加 frozenset 是没问题的，因为 frozenset 是不可变的，但是向 set 中添加 set，这是不允许的，因为 set 是可变的。