大家好呀,今天的内容有点多,这一课全面梳理了 Python 的几种数据容器:字符串、列表、字典、元组、集合的定义、特性以及一些增删改查的基本操作。之前学得比较零碎,或者概念比较混淆的同学也可以系统地过一遍加深印象、进一步理解和区分这几种数据容器。
一、字符串(str)
1. 字符串的定义
被单引号、双引号、三引号包围的字符组,就是字符串,例如:
str = 'hello'
str = "world"
str = """hello
Python"""
#定义多行字符串变量
2. 下标和切片
(1)下标索引
根据下标找到元素位置,索引从 0 开始:
name = 'zhangsan'
print(name[2])
输出结果为a
(2)切片
利用下表索引从字符串里截取一段元素,切片的语法是: [起始:结束:步长]。字符串、列表、元组都支持切片操作。
name = 'abcdef'
print(name[0:3])
# 取 下标0~2 的字符
运行结果:
abc
name = 'abcdef'
print(name[3:5])
# 取 下标为3、4 的字符
运行结果 :
de
name = 'abcdef'
print(name[2:])
# 取 下标为2开始到最后的字符
运行结果:
cdef
同样支持负数:
name = 'abcdef'
print(name[1:-1]) # 取 下标为1开始 到 最后第2个 之间的字符运行结果:
bcde
a = "abcdef" a[:3]
'abc' a[::2]
'ace' a[5:1:2] '' a[1:5:2]
'bd' a[::-2]
'fdb' a[5:1:-2]
'fd'
3. 字符串的增删改查
假如有字符串 mystr = 'hello world kkb':
(1)查: find
、index
、count
、startswith
、endswith
、rfind
、rindex
① find
检测 str
是否包含在 mystr
中,如果是,返回开始的索引值,否则返回-1
mystr.find(str, start=0, end=len(mystr))
例如:
mystr = 'hello world kkb'
mystr.find("kkb")
运行结果为:12
mystr = 'hello world kkb'
mystr.find("kkb",0,10)
#在mystr字符串0-10下标范围查询
运行结果:-1
② index
跟 find()
方法一样,只不过如果 str 不在 mystr 中会报一个异常。
mystr.index(str, start=0, end=len(mystr))
例如:
mystr = 'hello world kkb'
mystr.index("ab")
运行结果:控制台会直接报错(Vale Error:substring not found)
③ count
返回 str 在 start 和 end 之间 在 mystr 里出现的次数:
mystr.count(str, start=0, end=len(mystr))
例如:
mystr = 'hello world kkb and kkb'
mystr.count('kkb')
运行结果:2
④ startswith
检查字符串是否是以 hello
开头,是则返回 True
,否则返回 False
:
mystr.startswith('hello')
⑤ endswith
检查字符串是否以 obj
结束,如果是返回 True
,否则返回 False
:
mystr.endswith(obj)
⑥ rfind
类似于 find()
函数,不过是从右边开始查找:
mystr.rfind(str, start=0,end=len(mystr))
⑦ rindex
类似于 index() ,不过是从右边开始:
mystr.rindex(str, start=0,end=len(mystr))
(2)增
join
mystr
中每个元素后面插入 str
,构造出一个新的字符串:
str.join(mystr)
(3)删
① lstrip
删除 mystr
左边的空白字符:
mystr.lstrip()
② rstrip
删除 mystr
字符串末尾的空白字符:
mystr.rstrip()
③ strip
删除 mystr
字符串两端的空白字符:
a = "\n\t kkb \t\n"
a.strip()
运行结果:
'kkb'
(4)改
① replace
把 mystr
中的 str1
替换成 str2
,如果 count
指定,则替换不超过 count
次:
mystr.replace(str1, str2, mystr.count(str1))
② split
以 str
为分隔符切片 mystr
,如果 maxsplit
有指定值,则仅分隔 maxsplit
个子字符串:
mystr.split(str=" ", 2)
③ capitalize
把字符串的第一个字符大写:
mystr.capitalize()
④ title
返回“标题化”的字符串,所有单词都以大写开始,其余字母均为小写:
a = "hello kkb"
a.title()
运行结果
'Hello Kkb'
⑤ lower
转换 mystr
中所有大写字符为小写:
mystr.lower()
⑥ upper
转换 mystr
中的小写字母为大写:
mystr.upper()
⑦ ljust
返回一个原字符串左对齐,并使用空格填充至 width
长度的新字符串:
mystr.ljust(width)
⑧ rjust
返回一个原字符串右对齐,并使用空格填充至长度 width
的新字符串:
mystr.rjust(width)
⑨ center
返回一个原字符串居中,并使用空格填充至 width
长度的新字符串:
mystr.center(width)
⑩ partition
把 mystr
以 str
分割成三部分,str
前、str
和 str
后:
mystr.partition(str)
⑪ rpartition
类似于 partition()
函数,不过是从右边开始:
mystr.rpartition(str)
⑫ splitlines
按照行分隔,返回一个包含各行作为元素的列表:
mystr.splitlines()
二、列表(list)
1. 列表简介
列表是一种有序的集合,可以随时添加和删除其中的元素,写在方括号之间、用逗号分隔开的数值列表。列表内的项目不必全是相同的类型(这点是比C语言的数组强大的地方)。
例如:
list1 = ['Mike', '张三', 25000, 99.99, True]
2. 列表的增删改查
(1)列表的长度
# 用 len() 函数可以获得 list 元素的个数:
namesList = ['xiaoWang','xiaoZhang','xiaoHua']
len(namesList)
(2)列表的访问
用索引来访问 list 中每一个位置的元素,与字符串的索引相同,列表的索引也是从0开始的:
namesList = ['Tony','Rose','Lucy']
print(namesList[0])
print(namesList[1])
print(namesList[2])
结果:
Tony
Rose
Lucy
如果索引超出当前列表范围,例如如果输入 print(namesList[3])
,系统就会报错:IndexError: list index out of range
。所以,要确保索引不越界,最后一个元素的索引是 len(classmates) - 1
。
此外,还可以通过 -1
来取最后一个元素:
namesList = ['Tony','Rose','Lucy']
print(namesList[-1])
结果:
Lucy
以此类推,-2
、-3
可以获取倒数第2个、倒数第3个元素:
namesList = ['Tony','Rose','Lucy']
print(namesList[-1])
print(namesList[-2])
print(namesList[-3])
结果:
Lucy
Rose
Tony
(3)列表的切片
切片是根据下标的范围获取一部分数据。
切片的使用格式:
数据[起始下标:结束下标:步长]
注意:起始下标默认0, 结束下标是不包含(也就是取左不取右), 步长默认是1
# 使用切片的方式获取一部分数据
my_str = ['Mike', '张三', 25000, 99.99, True]
result = my_str[1:4:1]
print(result)
#前三个
result = my_str[0:3]
print(result)
result = my_str[:3]
print(result)
(4)添加元素(append
、extend
、insert
)
通过 append 可以向列表添加元素:
#定义变量A,默认有3个元素
namesListA = ['ZhangSan','LiSi','WangWu']
print("-----添加之前,列表A的数据-----")
for tempName in namesListA:
print(tempName)
#提示、并添加元素
temp = input('请输入要添加的学生姓名:')
namesListA.append(temp)
print("-----添加之后,列表A的数据-----")
for tempName in namesListA:
print(tempName)
通过 extend
可以将另一个集合中的元素逐一添加到列表中:
#append:
a = [1, 2, 3]
b = [4, 5, 6]
a.append(b)
print(a)
结果:
[1, 2, 3, [4, 5, 6]]
#extend:
a = [1, 2, 3]
b = [4, 5, 6]
a.extend(b)
print(a)
结果:
[1, 2, 3, 4, 5, 6]
# insert
insert(index, object)` 在指定位置`index`前插入元素`object
a = [1, 2, 3]
a.insert(1,100)
print(a)
结果:
[1, 100, 2, 3]
(5)修改元素
修改元素时,要通过下标来确定要修改哪个元素,然后才能进行修改:
#定义变量namesListA,默认有4个元素
namesListA = ['ZhangSan','LiSi','WangWu','ZhaoLiu']
print("-----修改之前,列表A的数据-----")
for tempName in namesListA:
print(tempName)
# 修改元素
namesListA[1] = '张三'
print("-----修改之后,列表A的数据-----")
for tempName in namesListA:
print(tempName)
结果:
-----修改之前,列表A的数据-----
ZhangSan
LiSi
WangWu
ZhaoLiu
-----修改之后,列表A的数据-----
ZhangSan
张三
WangWu
ZhaoLiu
(6)查找元素
所谓的查找,即查找指定元素是否存在。
python 中查找的常用方法为:
-
in
(存在),如果存在那么结果为true
,否则为false
-
not in
(不存在),如果不存在那么结果为true
,否则false
#待查找的列表
namesListA = ['ZhangSan','LiSi','WangWu','ZhaoLiu']
#获取用户要查找的名字
findName = input('请输入要查找的姓名:')
#查找是否存在
if findName in namesListA:
print('在列表中找到了相同的名字')
else:
print('没有找到')
index
和 count
与字符串中的用法相同:
>>> a = ['a', 'b', 'c', 'a', 'b']
>>> a.index('a', 1, 3) # 注意是左闭右开区间
Traceback (most recent call last):
File "", line 1, in
ValueError: 'a' is not in list
>>> a.index('a', 1, 4)
3
>>> a.count('b')
2
>>> a.count('d')
0
(7)删除元素
列表元素的常用删除方法有:
-
del
: 根据下标进行删除; -
pop
:删除最后一个元素; -
remove
:根据元素的值进行删除;
① del
list1 = ['a','b','c','d','e','f']
print('------删除之前------')
for tempName in list1:
print(tempName)
del list1[2]
print('------删除之后------')
for tempName in list1:
print(tempName)
结果:
------删除之前------
a
b
c
d
e
f
------删除之后------
a
b
d
e
f
② pop
list2 = ['a','b','c','d','e','f']
print('------删除之前------')
for tempName in list2:
print(tempName)
list2.pop()
print('------删除之后------')
for tempName in list2:
print(tempName)
结果:
------删除之前------
a
b
c
d
e
f
------删除之后------
a
b
c
d
e
③ remove
list3 = ['a','b','c','d','e','f']
print('------删除之前------')
for tempName in list3:
print(tempName)
list3.remove('e')
print('------删除之后------')
for tempName in list3:
print(tempName)
结果:
------删除之前------
a
b
c
d
e
f
------删除之后------
a
b
c
d
f
(8)排序 sort
sort 方法是将 list 按特定顺序重新排列,默认为由小到大,参数 reverse=True
可改为倒序,由大到小。reverse 方法是将 list 逆置。
a = [1, 4, 2, 3]
print(a)
结果:[1, 4, 2, 3]
a.reverse()
print(a)
结果:[3, 2, 4, 1]
a.sort()
print(a)
结果:[1, 2, 3, 4]
a.sort(reverse=True)
print(a)
结果:[4, 3, 2, 1]
3. 列表的遍历
(1)使用 for 循环
为了更有效率的输出列表的每个数据,可以使用循环来完成:
namesList = ['ZhangSan','LiSi','WangWu','ZhaoLiu']
for name in namesList:
print(name)
结果:
ZhangSan
LiSi
WangWu
ZhaoLiu
(2)使用while循环
namesList = ['ZhangSan','LiSi','WangWu','ZhaoLiu']
length = len(namesList)
i = 0
while i
三、元组(tuple)
元组(tuple)是另一种有序列表,它和 list 非常类似,但是 tuple 一旦初始化就不能修改,比如同样是列出同学的名字:
>>> classmates = ('Michael', 'Bob', 'Tracy')
现在, classmates 这个 tuple 不能变了,它也没有 append()
、 insert()
这样的方法,不过,其他获取元素的方法 tuple 和 list 是一样的,比如还是可以用 classmates[0]
、classmates[-1]
来取值,但不能赋值成另外的元素。
tuple 存在的意义在于,由于 tuple 不可变,所以代码更安全。如果可能,能用 tuple 代替 list 就尽量用 tuple 。
注意:如果要定义一个空的 tuple ,可以写成 () :
>>> t = ()
>>> t ()
但是,要定义一个只有1个元素的 tuple ,如果你这么定义:
>>> t = (1)
>>> t 1
那么你定义的不是tuple,而是1这个数!这是因为括号 () 既可以表示 tuple,又可以表示数学公式中的小括号,这就产生了歧义,因此,Python规定,这种情况下,按小括号进行计算,计算结果自然是1。
所以,只有1个元素的tuple定义时必须加一个逗号,来消除歧义:
>>> t = (1,)
>>> t (1,)
Python在显示只有1个元素的 `tuple 时,也会加一个逗号,以免你误解成数学计算意义上的括号。
最后来看一个“可变的”tuple:
>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])
也就是说,元组中的列表的值是可以改变的。
四、字典(dict)
1. 字典简介
字典是另一种可变容器模型,且可存储任意类型对象。字典的每个键值(key=>value)对用冒号 :
分割,每个对之间用逗号 ,
分割,整个字典包括在花括号 {}
中。
例如,要根据姓名查询成绩,可以通过一个姓名-成绩对照表:
>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael']
95
由于一个 key 只能对应一个 value ,所以,多次对一个 key 放入 value,后面的值会把前面的值冲掉:
>>> d['Jack'] = 90
>>> d['Jack']
90
>>> d['Jack'] = 88
>>> d['Jack']
88
如果key不存在,dict 就会报错:
>>> d['Thomas']
Traceback (most recent call last):
File "", line 1, in
KeyError: 'Thomas'
2. 字典的增删改查
(1)修改元素
字典的每个元素中的数据是可以修改的,只要通过 key 找到,即可修改:
info = {'name':'kkb', 'id':100, 'sex':'f', 'address':'中国北京'}
new_id = input('请输入新的学号:')
info['id'] = int(new_id)
print('修改之后的id为: %d' % info['id'])
(2)添加元素
访问不存在的元素
info = {'name':'kkb', 'sex':'f', 'address':'中国北京'}
print('id为:%d' % info['id'])
结果:
>>> info = {'name':'kkb', 'sex':'f', 'address':'中国北京'}
>>>
>>> print('id为:%d' % info['id'])
Traceback (most recent call last):
File "", line 1, in
KeyError: 'id'
如果在使用 变量名['键'] = 数据 时,这个“键”在字典中,不存在,那么就会新增这个元素。
添加新的元素:
info = {'name':'kkb', 'sex':'f', 'address':'中国北京'}
# print('id为:%d'%info['id'])
#程序会终端运行,因为访问了不存在的键
newId = input('请输入新的学号:')
info['id'] = newId
print('添加之后的id为:%d' % info['id'])
结果:
请输入新的学号:188
添加之后的id为: 188
(3)删除元素
对字典进行删除操作,有以下几种:
del
clear()
① del
删除指定的元素
info = {'name':'kkb', 'sex':'f', 'address':'中国北京'}
print('删除前,%s' % info['name'])
del info['name']
print('删除后,%s' % info['name'])
结果
>>> info = {'name':'kkb', 'sex':'f', 'address':'中国北京'}
>>>
>>> print('删除前,%s' % info['name'])
删除前,kkb
>>>
>>> del info['name']
>>>
>>> print('删除后,%s' % info['name'])
Traceback (most recent call last):
File "", line 1, in
KeyError: 'name'
② del
删除整个字典
info = {'name':'monitor', 'sex':'f', 'address':'China'}
print('删除前,%s' % info)
del info
print('删除后,%s' % info)
③ clear
清空整个字典
info = {'name':'monitor', 'sex':'f', 'address':'China'}
print('清空前,%s' % info)
info.clear()
print('清空后,%s' % info)
(4)其他操作
① len()
测量字典中,键值对的个数:
d1 = {'name':'abc','age':'18', 'class':'cnh'}
print(len(d1))
结果:
3
② keys
返回一个包含字典所有key的列表:
d1 = {'name':'abc','age':'18', 'class':'cnh'}
print(list(d1.keys()))
结果:
['name', 'age', 'class']
③ values
返回一个包含字典所有value的列表:
d1 = {'name':'abc','age':'18', 'class':'cnh'}
print(list(d1.values()))
结果:
['abc', '18', 'cnh']
④ items
返回一个包含所有(键,值)元祖的列表:
d1 = {'name':'abc','age':'18', 'class':'cnh'}
print(list(d1.items()))
结果:
[('name', 'abc'), ('age', '18'), ('class', 'cnh')]
5、集合(set)
集合(set)是一个无序的不重复元素序列。可以使用大括号 { }
或者 set()
函数创建集合。
注意:
(1)创建一个空集合必须用 set()
而不是 { }
,因为 { }
是用来创建一个空字典。
(2)集合不支持下标赋值和取值,因为集合元素没有顺序,因此没有序列的概念。
my_set = {1, 4, 'abc', 'hello'}
#通过遍历获取数据
my_set = {1, 5, 7}
for value in my_set:
print(value)
for index,value in enumerate(my_set):
print(index,value)
# 定义空的集合的时候不能直接使用{}
my_set = set()
my_set.add(1)
my_set.add(1)
print(my_set, type(my_set))
# 这里 my_set 仍然只有一个元素1,因为集合元素不能重复。
# 集合可以对容器类型数据去重
my_list = [1, 1, 3, 5, 3]
# 把列表转成集合,会把数据去重
my_set = set(my_list)
print(my_set)
# 输出结果为 {1, 3, 5}
# 列表,元组, 集合 三者之间可以相互转换
my_tuple = (5, 3)
my_tuple = set(my_tuple)
print(my_tuple, type(my_tuple))
# 输出结果为 {3, 5}