欢迎交流学习~~


专栏: Python学习笔记


Python学习系列:
Python | 基础入门篇Part01——注释、数据类型、运算符、字符串
Python | 基础入门篇Part02——判断语句、循环语句、函数初步


Python | 基础入门篇Part03——数据容器

  • 八、数据容器
    • 8.1 列表
    • 8.2 元组
    • 8.3 字符串
    • 8.4 序列的切片
    • 8.5 集合
    • 8.6 字典

八、数据容器

前面我们已经提到过数据元素的两种类型:数字和字符串,接下来我们将引入剩下的:列表、元组、集合和字典。

数据容器:
数据容器是一种可以容纳多份数据的数据类型,容纳的每一份数据称之为一个元素,每一个元素可以是任意类型的数据,如字符串、数字、布尔等。

数据容器的划分:
数据容器根据特点的不同,如:

  • 是否支持重复元素;
  • 是否可以修改;
  • 是否有序;

分为 5类,分别为:

  • 列表 list
  • 元组 tuple
  • 字符串 str
  • 集合 set
  • 字典 dict

8.1 列表

列表的定义:
列表定义的基本语法为:

"""字面量"""[元素1, 元素2, 元素3...]"""定义变量"""变量名称 = [元素1, 元素2, 元素3...]"""定义空变量"""变量名称 = []变量名称 = list[]
  • 列表内的每一个数据,称之为 元素,元素类型可以任意
  • 列表以 [] 为标识
  • 列表内的每一个元素之间用逗号隔开

我们用一个例子来说明:

lis = ['name', 18, True, [98, 95, 96]]print(lis)print(type(lis))


我们注意到,在列表中,还存在着一个列表,这叫做 列表的嵌套
列表的索引:
列表中的元素是有顺序的,从左到右的索引从 0 开始,即第一个元素的索引为 0,之后逐个增加。
列表的索引也可以从右向左取,此时的索引从 -1 开始,即最后一个元素的索引为 -1,之后逐个减少。

如果我们想要取出列表中某个元素进行操作,我们可以利用列表的索引,具体方法是 list[索引]
我们用一个例子说明:

lis = ['name', 18, True, [98, 95, 96]]print(lis[0])print(lis[1])print(lis[2])print(lis[3])print(lis[-1])print(lis[-2])print(lis[-3])print(lis[-4])


注意到,因为最后一个元素是列表,那我们如何取出其中元素进行操作?只需要再附加一个索引即可,比如:

lis = ['name', 18, True, [98, 95, 96]]print(lis[3][0])print(lis[-1][1])print(lis[-1][-1])


我们还可以利用索引对列表元素进行修改:

lis = ['name', 18, True, [98, 95, 96]]print(lis)lis[1] = 20print(lis)

列表的常用操作方法:
列表除了定义,以及使用索引获取其中的元素,也可以:查找元素索引,插入元素,删除元素,清空列表,修改列表,统计元素个数等等。

这些功能,我们称之为:列表的方法

在前面中我们提到了函数,若函数定义为 Class(类) 的成员,那么函数会称之为 方法
方法和函数一样,有传入参数,有返回值,只是方法的使用格式不同:
函数的使用:
func()
方法的使用:
member = Class()
member.func()

列表 方法 的用法:

  • 查询元素索引 index()
    • 功能:在列表中从前往后找到第一个指定元素的索引,并返回;如果找不到,则报错;
    • 语法:列表.index(元素)
lis = ['name', 18, True, [98, 95, 96]]print(lis.index('name'))

  • 插入元素 insert()
    • 功能:在指定索引位置插入指定元素;
    • 语法:列表.insert(索引,元素)
lis = ['name', 18, True, [98, 95, 96]]print(lis)lis.insert(1, 'male')print(lis)

  • 添加元素 append()extend()
    • 功能:在列表末尾添加元素,append() 只能添加一个,extend() 能添加多个;
    • 语法:列表.append(元素)列表.extend()
lis = ['name', 18, True, [98, 95, 96]]print(lis)lis.append('male')print(lis)lis.extend([1, 2, 3])print(lis)

  • 删除元素 del list[索引]pop(索引)
    • 功能:删除指定索引位置元素,del list[索引] 直接删除,而 pop(索引) 会将删除元素返回;
    • 语法:del 列表[索引]列表.pop(索引)pop() 若不指定索引,默认为 -1
lis = ['name', 18, True, [98, 95, 96]]print(lis)del lis[0]print(lis)d = lis.pop(1)print(lis)print(d)

  • 删除指定元素 remove()
    • 功能:删除某元素在列表中的第一个匹配项
    • 语法:列表.remove(元素)
lis = ['name', 18, True, [98, 95, 96], 18]lis.remove(18)print(lis)

  • 清空列表 clear()
    • 功能:清空列表中的元素
    • 语法:列表.clear()
lis = ['name', 18, True, [98, 95, 96], 18]lis.clear()print(lis)

  • 统计指定元素个数 count()
    • 功能:统计列表中指定元素的个数
    • 语法:列表.count(元素)
lis = ['name', 18, True, [98, 95, 96], 18]print(lis.count('name'))print(lis.count(18))

  • 返回列表元素个数 len()
    • 功能:统计列表中元素的个数,并返回
    • 语法:len(列表)
lis = ['name', 18, True, [98, 95, 96]]print(len(lis))


列表的遍历:
列表的遍历可以用 whilefor 循环语句实现:
while语句

lis = ['name', 18, True, [98, 95, 96]]index = 0while index < len(lis):print(lis[index])index += 1

for语句
for语句有两种方法实现,一种是利用 range() 函数通过索引遍历,一种是直接遍历。

lis = ['name', 18, True, [98, 95, 96]]for i in range(len(lis)):print(lis[i])
lis = ['name', 18, True, [98, 95, 96]]for i in lis:print(i)

8.2 元组

元组同列表一样,都是可以封装多个、不同类型的元素在内,但是,元组一旦完成,就 不能修改。因此我们可以将元组看作 只读 的列表。

所以,当我们封装完数据后,希望其不被更改,就可以用元组。
元组的定义:
元组的定义用 小括号,且使用 逗号 隔开各个元素,数据可以是不同的数据类型:

"""字面量"""(元素1, 元素2, 元素3...)"""定义变量"""变量名称 = (元素1, 元素2, 元素3...)"""定义空变量"""变量名称 = ()变量名称 = tuple()

我们用一个例子说明:

tup = ('name', 18, True, (98, 95, 96))print(tup)print(type(tup))


我们注意到,在元组中,还存在着一个元组,这叫做 元组的嵌套
元组的操作:
元组的操作和列表的操作类似,除了不可修改,其余操作相同:

  • 查询元素索引 index()
    • 功能:在元组中从前往后找到第一个指定元素的索引,并返回;如果找不到,则报错;
    • 语法:元组.index(元素)
tup = ('name', 18, True, [98, 95, 96])print(tup.index(18))

  • 统计指定元素个数 count()
    • 功能:统计元组中指定元素的个数
    • 语法:元组.count(元素)
tup = ('name', 18, True, [98, 95, 96], True)print(tup.count(18))print(tup.count(True))

  • 返回元组元素个数 len()
    • 功能:统计元组中元素的个数,并返回
    • 语法:len(元组)
tup = ('name', 18, True, [98, 95, 96])print(len(tup))

元组的遍历:
元组遍历和列表相同:

tup = ('name', 18, True, (98, 95, 96))index = 0while index < len(tup):print(tup[index])index += 1
tup = ('name', 18, True, (98, 95, 96))for i in range(len(tup)):print(tup[i])
tup = ('name', 18, True, (98, 95, 96))for i in tup:print(i)

8.3 字符串

字符串是字符的容器,一个字符可以存放任意数量的字符。

字符串和其他容器一样,有索引,从 0 开始,可以通过索引取出字符串中的字符,比如:

s = 'this is a str'print(s[2])print(s[-1])


字符串的操作:
字符串不能被修改,即不能对原字符串本身直接修改,但是可以操作后返回一个新的字符串。

  • 查找指定字符索引 index()
    • 功能:返回指定字符的第一个匹配项的索引;
    • 用法:字符串.index('指定字符')
s = 'this is a str'print(s.index('i'))

  • 字符串的替换 replace()
    • 功能:替换字符串的指定子串
    • 用法:字符串.replace(要替换的子串, 替换的内容)
s = 'this is a str'new_s = s.replace('is', 'new')print(s)print(new_s)

  • 字符串的分割 split()
    • 功能:按照指定的分隔符字符串,将字符串划分为多个字符串,并存入列表中;
    • 用法:字符串.split(分隔字符串) 分隔字符串默认为 ' '空格
s = 'this is a str'lis1 = s.split()lis2 = s.split('s')print(s)print(lis1)print(lis2)

  • 字符串的规整strip()
    • 功能:去除字符串开头和结尾的指定字符;
    • 用法:字符串.strip(指定字符) 指定字符默认为空格
s = ' rt: this is a str's1 = s.strip()s2 = s.strip(' rt')print(s)print(s1)print(s2)

我们注意到 s2 对应传入的参数是 ' rt',其实,strip() 函数是按照单个字符移除,即 ' ''r''t' 都会移除。

  • 统计字符串中某子串的出现次数 count()
    • 功能:返回字符串中某子串出现的次数;
    • 用法:字符串.count(指定子串)
s = ' rt: this is a str'num = s.count('t')print(num)

  • 统计字符串长度 len()
    • 功能:返回字符串的长度;
    • 用法:len(字符串)
s = ' rt: this is a str'num = len(s)print(num)


字符串的 遍历和切片 和列表相同,这里不做具体说明。

8.4 序列的切片

我们前面学习了 列表、元组和字符串,这些数据容器都有这样的特点:内容连续、有序且可使用索引,我们称这样的数据容器为 序列

我们有时需要取出序列中多个元素,这时候就要利用到 切片 操作。
切片: 从一个序列中,取出一个子序列:

  • 语法:序列[起始索引:结束索引:步长]
  • 表示从指定位置开始,依次取出元素,到指定位置结束,得到一个新序列
    • 起始索引表示从何处开始,默认为从 0 开始;
    • 结束索引表示到何处结束(但不包括结束索引本身),默认为到结尾 -1
    • 步长表示依次取元素的间隔,步长 N 表示,每次跳过 N-1 个元素取,步长若为负数则反向取,步长默认为 1
    • 起始索引也未必要小于结束索引,如果起始索引较大,步长则需为负,可以表示反向取。

我们以实际举例:

lis = ['tom', 18, 98, 95, 96]tup = (1, 2, 3, 4, 5, 6, 7, 8)s = 'this is a string'print(lis[1:-1])print(lis[1:-1:-2])print(tup[2:6:2])print(tup[6:2:-2])print(s[::-1])print(s[::-2])

8.5 集合

前面我们学到的列表、元组和字符串,它们都支持重复元素,而集合则不支持重复元素,因此集合可以用于去重等目的。
集合的定义:
集合的定义与列表基本相同:

"""字面量"""{元素1, 元素2, 元素3...}"""定义变量"""变量名称 = {元素1, 元素2, 元素3...}"""定义空变量"""变量名称 = set()

我们以一个例子说明:

se1 = {1, 2, 3, 4, 2, 1}se2 = set()print(se1)print(se2)print(type(se2))

因为集合是无序的,因此其不存在索引。
但集合允许修改。

集合的操作:

  • 添加新元素 add()
    • 功能:在集合中添加新元素
    • 用法:集合.add(新元素)
se = {1, 2, 3, 4, 2, 1}print(se)se.add(5)print(se)se.add(4)print(se)

  • 移除元素 remove()
    • 功能:移除指定元素;
    • 用法:集合.remove(指定元素),集合中没有指定元素会报错
se = {1, 2, 3, 4, 2, 1}print(se)se.remove(1)print(se)

  • 随机取出元素 pop()
    • 功能:从集合中随机取出一个元素
    • 结果:会返回取出的元素,同时集合本身也被修改
se = {1, 2, 3, 4, 2, 1}print(se)ele = se.pop()print(ele)print(se)

  • 清空集合 clear
    • 功能:清空集合
    • 用法:集合.clear()
  • 集合的交 intersection()、并 union()、补 difference
    • 功能:实现集合的运算
    • 用法:集合A.intersection(集合B)集合A.union(集合B)集合A.difference(集合B)
se_a = {1, 2, 3, 4, 5, 6}se_b = {4, 5, 6, 7, 8, 9}se_i = se_a.intersection(se_b)se_u = se_a.union(se_b)se_d = se_a.difference(se_b)print(se_a)print(se_b)print(se_i)print(se_u)print(se_d)

8.6 字典

与集合类似,字典(dictionary)也是由若干无序的数据元素组成,与集合不同的是,字典是一种映射类型,字典中的每一个元素都有一个对应的键(key),即字典中的每个元素都是以 键: 值 对的形式出现。

其中键必须是可哈希的,即不包括列表、集合、字典等,但是值可以为任意类型。

字典的定义:
字典的定义可以用大括号 {}创建,也可以使用 dict() 函数,具体见如下示例代码:

d1 = {'x': 1, 'y': 2, 'z': 3}d2 = {'x': 1, 'y': 2, 'z': 3, 'x': 4}d3 = dict(x=1, y=2, z=3)d4 = dict([('x', 1), ('y', 2), ('z', 3)])d5 = dict()print(d1)print(d2)print(d3)print(d4)print(d5)

字典的操作:

  • 插入与修改,可以通过赋值操作直接修改,也可以使用 update() 方法
    • 功能:通过键名对字典元素进行修改,若键名不存在则插入新的元素
    • 用法:字典[键]=值字典.update(键=值)字典1.update(字典2)
d1 = {'x': 1, 'y': 2, 'z': 3}print(d1)d1['x'] = 4d1['w'] = 5print(d1)d1.update(y=6)d1.update(v=7)print(d1)d2 = {'q': 100, 'r': 1000}d1.update(d2)print(d1)

  • 删除 del
    • 功能:删除字典中的指定元素
    • 用法:del 字典[键]
d1 = {'x': 1, 'y': 2, 'z': 3}print(d1)del d1['x']print(d1)

  • 删除并返回值 pop()
    • 功能:删除并返回指定元素值
    • 用法:值=字典.pop(键)
d1 = {'x': 1, 'y': 2, 'z': 3}print(d1)out = d1.pop('y')print(d1)print(out)

  • 删除并返回键值对 popitem()
    • 功能:删除并返回最后一对键值对
    • 用法:
d1 = {'x': 1, 'y': 2, 'z': 3}print(d1)out = d1.popitem()print(d1)print(out)

  • 判断是否存在指定的键 get()
    • 功能:判断字典中是否存在指定的键,若不存在,则返回默认值
    • 用法:字典.get(key, default)
d1 = {'x': 1, 'y': 2, 'z': 3}print(d1.get('x', 'No'))print(d1.get('w', 'No'))

  • 获取字典中的所有元素 items(),或使用 keys()values() 返回字典中所有键或者值
    • 功能:返回键值对,或只返回键或者值
    • 用法:字典.items()字典.keys()字典.values()
d1 = {'x': 1, 'y': 2, 'z': 3}for k, v in d1.items():print(f'{k}: {v}')for k in d1.keys():print(k)for v in d1.values():print(v)

  • 拷贝 copy()
    • 功能:将一个字典复制一份,赋值给另一个,两个字典的修改不会相互影响
    • 用法:字典2=字典1.copy()
d1 = {'x': 1, 'y': 2, 'z': 3}d2 = d1.copy()d2['x'] = 4print(f'd1: {d1}')print(f'd2: {d2}')