计算机二级python 知识点篇（组合数据类型）

计算机二级python 知识点篇（组合数据类型）

集合、列表、字符串、元组、字典

• 集合类型 : 集合 （无序、无相同元素）
• 序列类型 ：列表、字符串、元组 （有序、元素之间不排他）
• 映射类型 ：字典

集合

集合概述

集合中元素不可重复， 元素类型只能是固定数据类型，例如： 整数、 浮点数、 字符串、 元组等， 列表、 字典和集合类型本身都是可变数据类型， 不能作为集合的元素出现

>>>S = {1010, "1010", 78.9}
>>>type(S)
<class 'set'>
>>>len(S)
3
>>>print(S)
{78.9, 1010, '1010'}

• 集合操作符

集合类型有4个操作符， 交集（&） 、 并集（|） 、 差集（-） 、 补集（^） ，操作逻辑与数学定义相同

操作符的运算	描述
S – T 返回一个新集合，	包括在集合S中但不在集合T中的元素
S & T 返回一个新集合，	包括同时在集合S和T中的元素
S^T 返回一个新集合，	包括集合S和T中非共同元素
S|T 返回一个新集合，	包括集合S和T中所有元素

>>>S = {1010, "1010", 78.9}
>>>T = {1010, "1010", 12.3, 1010, 1010}
>>>S - T
{78.9}
>>>T – S
{12.3}
>>>S & T
{1010, '1010'}
>>>T & S
{1010, '1010'}
>>>S ^ T
{78.9, 12.3}
>>>T ^ S
{78.9, 12.3}
>>>S | T
{78.9, 1010, 12.3, '1010'}
>>>T | S
{1010, 12.3, 78.9, '1010'}

• 集合操作函数和方法

函数或方法	描述
S.add(x)	如果数据项x不在集合S中， 将x增加到s
S.remove(x)	如果x在集合S中， 移除该元素； 不在产生KeyError异常
S.clear()	移除S中所有数据项
len(S)	返回集合S元素个数
x in S	如果x是S的元素， 返回True， 否则返回False
x not in S	如果x不是S的元素， 返回True， 否则返回False

集合类型主要用于元素去重， 适合于任何组合数据类型

序列类型

序列类型包括 列表、字符串、元组 （有序、元素之间不排他）

• 序列类型操作符和函数

操作符	描述
x in s	如果x是s的元素， 返回True， 否则返回False
x not in s	如果x不是s的元素， 返回True， 否则返回False
s + t	连接s和t
s * n 或 n * s	将序列s复制n次
s[i]	索引， 返回序列的第i个元素
s[i: j]	切片， 返回包含序列s第i到j个元素的子序列（不包含第j个元素）
s[i: j: k]	步骤切片， 返回包含序列s第i到j个元素以k为步数的子序列
len(s)	序列s的元素个数（长度）
min(s)	序列s中的最小元素
max(s)	序列s中的最大元素
s.index(x)	序列s中第一次出现元素x的位置
s.count(x)	序列s中出现x的总次数

列表

• 列表类型用中括号（[]） 表示， 也可以通过list(x)函数将集合或字符串类型转换成列表类型

>>>ls = [1010, "1010", [1010, "1010"], 1010]
>>>ls
[1010, '1010', [1010, '1010'], 1010]
>>>list('列表可以由字符串生成')
['列', '表', '可', '以', '由', '字', '符', '串', '生', '成']
>>>list()
[]

# 索引
>>>ls = [1010, "1010", [1010, "1010"], 1010]
>>>ls[3]
1010
>>>ls[-2]
[1010, '1010']


# 遍历
>>>ls = [1010, "1010", [1010, "1010"], 1010]
>>>for i in ls:
print(i*2)
2020
10101010
[1010, '1010', 1010, '1010']
2020

# 切片
>>>ls = [1010, "1010", [1010, "1010"], 1010]
>>>ls[1:4]
['1010', [1010, '1010'], 1010]
>>>ls[-1:-3]
[]
>>>ls[-3:-1]
['1010', [1010, '1010']]
>>>ls[0:4:2]
[1010, [1010, '1010']]

• 列表的操作函数

操作函数	描述
len(ls)	列表ls的元素个数（长度）
min(ls)	列表ls中的最小元素
max(ls)	列表ls中的最大元素
list(x)	将x转变成列表类型

• 列表的操作方法

方法	描述
ls.append(x)	在列表ls最后增加一个元素x
ls.insert(i, x)	在列表ls第i位置增加元素x
ls.clear()	删除ls中所有元素
ls.pop(i)	将列表ls中第i项元素取出并删除该元素
ls.remove(x)	将列表中出现的第一个元素x删除
ls.reverse()	列表ls中元素反转
ls.copy()	生成一个新列表， 复制ls中所有元素

关于删除，还可以用Python保留字del对列表元素或片段进行删除， 使用方法如下：

 del <列表变量>[<索引序号>] 或
 del <列表变量>[<索引起始>: <索引结束>]

>>>lt = ["1010", "10.10", "Python"]
>>>del lt[1]
>>>print(lt)
["1010", "Python"]
>>>lt = ["1010", "10.10", "Python"]
>>>del lt[1:]
>>>print(lt)
["1010"]

关于 浅拷贝和深拷贝
深拷贝：.copy()方法复制后赋值给变量ls， 将lt元素清空不影响新生成的变量ls
浅拷贝：ls = lt语句并不是拷贝lt中元素给变量ls， 而是新关联了一个引用， 即ls和lt所指向的是同一套内容

字典类型

Python语言中的字典使用大括号{}建立， 每个元素是一个键值对， 使用方式如下：

{<键1>:<值1>, <键2>:<值2>, … , <键n>:<值n>}

• 字典的索引

列表类型采用元素顺序的位置进行索引。由于字典元素“键值对” 中键是值的索引，因此，可以直接利用键值对关系索引元素。
字典中键值对的索引模式如下， 采用中括号格式：

<值> = <字典变量>[<键>]

>>>d = {"201801":"小明", "201802":"小红", "201803":"小白"}
>>>print(d["201802"])
小红

# 利用索引和赋值（=） 配合， 可以对字典中每个元素进行修改。
>>>d["201802"] = '新小红'
>>>print(d)
{'201801': '小明', '201803': '小白', '201802': '新小红'}

# 使用大括号可以创建字典。 通过索引和赋值配合，可以向字典中增加元素。
>>>t = {}
>>>t["201804"] = "小新"
>>>print(d)
{'201804': '小新'}

• 字典的操作函数

操作函数	描述
len(d)	字典d的元素个数（长度）
min(d)	字典d中键的最小值
max(d)	字典d中键的最大值
dict()	生成一个空字典

• 字典的操作方法

操作方法	描述
d.keys()	返回所有的键信息
d.values()	返回所有的值信息
d.items()	返回所有的键值对
d.get(key, default)	键存在则返回相应值， 否则返回默认值
d.pop(key, default)	键存在则返回相应值， 同时删除键值对， 否则返回默认值
d.popitem()	随机从字典中取出一个键值对， 以元组(key, value)形式返回取出后从字典中删除这个键值对
d.clear()	删除所有的键值对

d.keys()返回字典中的所有键信息， 返回结果是Python的一种内部数据类型dict_keys， 专用于表示字典的键。如果希望更好的使用返回结果， 可以将其转换为列表类型
d.values()返回字典中的所有值信息， 返回结果是Python的一种内部数据类型dict_values。 如果希望更好的使用返回结果， 可以将其转换为列表类型。
d.items()返回字典中的所有键值对信息， 返回结果是Python的一种内部数据类型dict_items。

>>>d = {"201801":"小明", "201802":"小红", "201803":"小白"}
>>>d.keys()
dict_keys(['201801', '201802', '201803'])
>>>type(d.keys())
<class 'dict_keys'>
>>>list(d.keys())
['201801', '201802', '201803']

>>>d = {"201801":"小明", "201802":"小红", "201803":"小白"}
>>>d.values()
dict_values(['小明', '小红', '小白'])
>>>type(d.values())
<class 'dict_values'>
>>>list(d.values())
['小明', '小红', '小白']

>>>d = {"201801":"小明", "201802":"小红", "201803":"小白"}
>>>d.items()
dict_items([('201801', '小明'), ('201802', '小红'),
('201803', '小白')])
>>>type(d.items())
<class 'dict_items'>
>>>list(d.items())
[('201801', '小明'), ('201802', '小红'), ('201803', '小白')]


>>>d = {"201801":"小明", "201802":"小红", "201803":"小白"}
>>>d.get('201802')
'小红'
>>>d.get('201804')
>>>d.get('201804', '不存在')
'不存在

字典类型也支持保留字in， 用来判断一个键是否在字典中。 如果在则返回True， 否则返回False

>>>d = {"201801":"小明", "201802":"小红", "201803":"小白"}
>>>"201801" in d
True
>>>"201804" in d
False

• 遍历

与其他组合类型一样， 字典可以遍历循环对其元素进行遍历， 基本语法结构如下：

for <变量名> in <字典名>
<语句块>

for循环返回的变量名是字典的索引值。 如果需要获得键对应的值， 可以在语句块中通过get()方法获得

>>>d = {"201801":"小明", "201802":"小红", "201803":"小白"}
>>>for k in d:
print("字典的键和值分别是： {}和{}".format(k, d.get(k)))
字典的键和值分别是： 201801和小明
字典的键和值分别是： 201802和小红
字典的键和值分别是： 201803和小白