计算机二级python基础知识总结-计算机二级python 知识点篇（组合数据类型）

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

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

集合类型 : 集合 （无序、无相同元素）

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

映射类型 ：字典

集合

集合概述

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

>>>S = {1010, "1010", 78.9}

>>>type(S)

>>>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())

>>>list(d.keys())

['201801', '201802', '201803']

>>>d = {"201801":"小明", "201802":"小红", "201803":"小白"}

>>>d.values()

dict_values(['小明', '小红', '小白'])

>>>type(d.values())

>>>list(d.values())

['小明', '小红', '小白']

>>>d = {"201801":"小明", "201802":"小红", "201803":"小白"}

>>>d.items()

dict_items([('201801', '小明'), ('201802', '小红'),

('201803', '小白')])

>>>type(d.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和小白