python之旅（三）—— 列表、元组、字典、集合、字符串

在这一篇中，我将会对列表、元组、字典、集合的增、删、改、查操作进行学习，以及对字符串的各种操作进行简单地整合。

1. 列表

列表中的元素个数与元素内容都是可以改变的。我们可以通过列表来对数据进行批量操作。下面将讲讲列表的创建、访问与更新。

1.1 创建列表

创建列表的语法格式如下：

方法1：列表名 = [值1 , 值2 , 值3 , ...... , 值n]
方法2：使用list()函数创建，列表名=list(内容)
方法3：列表名 = [表达式 for 变量 in 序列]

• 列表是一种灵活的数据类型，在一个列表中的元素可以是相同类型的，也可以是不同类型的；列表中元素的数据量也是不固定的，可以赋入多个元素，也可以赋入单个元素，当然也可以是没有元素；
• 列表中的元素可以是整型、浮点型、字符串型这些简单的数据类型，也可以是列表、元组、字典、集合等组合数据类型；

下面是我在列表创建上做得实验：

#使用方法1：
>>> list1 = ["2018",19]
>>> list1
['2018', 19]
>>> list2 = []
>>> list2
[]
#使用方法2：
>>> list3 = list((1,2,3))
>>> list3
[1, 2, 3]
>>> list4 = list(range(1,6))
>>> list4
[1, 2, 3, 4, 5]
>>> list5 = list(list4)
>>> list5
[1, 2, 3, 4, 5]
>>> list6 = list(list3+list4)
>>> list6
[1, 2, 3, 1, 2, 3, 4, 5]
>>> list7 = list("Python程序设计")
>>> list7
['P', 'y', 't', 'h', 'o', 'n', '程', '序', '设', '计']
#使用方法3：
>>> list8 = [1/i for i in range(1,10)]
>>> list8
[1.0, 0.5, 0.3333333333333333, 0.25, 0.2, 0.16666666666666666, 0.14285714285714285, 0.125, 0.1111111111111111]

有些列表在不用之后，我们应该及时的删除列表，以节省存储空间，而删除列表我们一般用del来完成，其语法格式如下：

del	列表名

实验如下：

>>> list1
['2018', 19]
>>> del list1
>>> list1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'list1' is not defined

1.2 访问列表

列表是序列类型，其中的元素按照其所在的位置均有一个唯一的索引值，我们可以通过访问这个索引值，访问指定的元素。下面是访问列表中的元素的语法格式：

列表名[索引值]

• 这里需要注意的是，python中为列表设置了两套索引，这点与C语言不同，这两套索引分别是：正向索引与逆向索引；
• 正向索引的索引值是从0开始递增，逆向索引的索引值是从-1开始递减。

下面是我进行的访问列表元素的实验：

>>> list1 = list(range(1,10))
>>> list1
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list1[4]
5
>>> list1[-5]
5
>>> list1[8]
9
>>> list1[-1]
9
>>> list1[0] = list1[-1]
>>> list1
[9, 2, 3, 4, 5, 6, 7, 8, 9]

一般我们在访问列表中的元素时，需要知道列表中有多少元素，这时我们需要用到len()函数来自动计算列表的长度。以下是我在这方面进行的实验：

>>> source_list = list(range(1,50,2))
>>> num = 0
>>> for i in source_list:
...     num+=1
...
>>> print(num)
25
#使用len()函数可以达到以上代码的效果
>>> len(source_list)
25

1.3 更新列表

创建完列表后，我可以对列表中的元素进行增加、删除、修改操作。下面是对这三个操作的简单说明，以及对列表中常用到的一些操作的总结。

1.3.1 增加列表元素

增加列表元素的语法格式有如下的两种：

方法1：列表名.append(新增元素值)
方法2：列表名.insert(索引值，新增元素值)

上述讲到的两种方法的区别如下：append()函数是在列表的末尾追加元素，而insert()函数可以在列表的指定位置插入元素。
下面是我使用这两种方法对一个列表进行增值操作：

>>> list1 = []
>>> list1
[]
>>> list1.append([1,2])
>>> list1
[[1, 2]]
>>> list1.append("python")
>>> list1
[[1, 2], 'python']
>>> list1.insert(0,10)
>>> list1
[10, [1, 2], 'python']
#下面这几行需要注意，我指定的位置已经超过列表已有的序列，默认当成在列表末尾后增值
>>> list1.insert(4,8)
>>> list1
[10, [1, 2], 'python', 8]
>>> list1.insert(10,("python","程序"))
>>> list1
[10, [1, 2], 'python', 8, ('python', '程序')]
>>> list1.insert(5,10.98)
>>> list1
[10, [1, 2], 'python', 8, ('python', '程序'), 10.98]
#这里要注意的是append()函数每次只能向列表添加一个值
>>> list1 = []
>>> list1.append(1,2,3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: append() takes exactly one argument (3 given)

1.3.2 删除列表元素

在前面的创建列表中，我已经提到过一种删除列表的方法，即使用del，但上面讲的是将整个列表全部删除，如果只想删除列表中的某个元素，我们可以使用以下两种格式：

方法1：列表名.remove(元素值)
方法2：del 列表名[索引值]

其中，我们需要注意remove()函数是从列表中删除指定的值，如果一个列表中有多个值和指定值相同，只删除第一个值。
下面是我对这两个方法进行的实验：

>>> list1 = [1,2,3,4,5]
>>> list1
[1, 2, 3, 4, 5]
>>> list1.remove(1)
>>> list1
[2, 3, 4, 5]
>>> list1.insert(0,1)
>>> list1
[1, 2, 3, 4, 5]
>>> list1.append(1)
>>> list1
[1, 2, 3, 4, 5, 1]
>>> list1.remove(1)
>>> list1
[2, 3, 4, 5, 1]
>>> del list1[2]
>>> list1
[2, 3, 5, 1]
#这里我想验证如果列表中还有一个列表中也有1个值为1，这个值应如何删除
>>> list1.append([1,2,3])
>>> list1.append(1)
>>> del list1[-1]
>>> list1
[2, 3, 5, 1, [1, 2, 3]]
>>> del list1[3]
>>> list1.append(1)
>>> list1
[2, 3, 5, [1, 2, 3], 1]
>>> list1.remove(1)
>>> list1
[2, 3, 5, [1, 2, 3]]
#从下面这两个操作可以看出想将列表中列表的值删除，我们只可以用del
>>> list1.remove(1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list
>>> del list1[-1][0]
>>> list1
[2, 3, 5, [2, 3]]

1.3.3 修改列表元素值

对于修改列表元素值，我们可以通过赋值语句的形式，用新元素值替换指定位置的现有元素值，其语法格式如下：

列表名[索引值] = 新元素值

上面这种方式只是修改了某个给定位置对应的元素值，我们还可以通过下面的方式修改某个范围的元素值。

列表名[i:j] = 元素值

使用这种方式时要注意：如果给定的新值个数少于指定范围内的元素值个数，相当于删除元素值；如果给定的新值个数多于指定范围内的元素值个数，则相当于增加元素值。
下面是我进行的实验：

>>> list1 = ["张三",19,"2019837","学生","群众"]
>>> list1
['张三', 19, '2019837', '学生', '群众']
#元素值为列表中只有个字符串，表示要修改成的值是个列表
>>> list1[0]=["李四"]
>>> list1
[['李四'], 19, '2019837', '学生', '群众']
#直接输入一个字符串默认输入两个字符
>>> list1[-1:] = "团员"
>>> list1
[['李四'], 19, '2019837', '学生', '团', '员']
#修改列表中的数值时，需要用中括号括起来
>>> list1[-1:]=[10]
>>> list1
[['李四'], 19, '2019837', '学生', '团', 10]
>>> list1[-1:-2]=10
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only assign an iterable
>>> list1[-1:-3]=[0]
>>> list1
[['李四'], 19, '2019837', '学生', '团', 0, 10]
>>> list1[1:3]=[18]
>>> list1
[['李四'], 18, '学生', '团', 0, 10]
>>> list1[:2]=["张无",20]
>>> list1
['张无', 20, '学生', '团', 0, 10]
>>> list1[:2]=["李留",21,"农民"]
>>> list1
['李留', 21, '农民', '学生', '团', 0, 10]

在上面的实验中看到了下面这几个点：

• 列表名[i:j]表示的是第i个元素到第j-1个元素，并不包括第j个元素；
• 列表名[i:j]中，如果省略了i，默认列表从下标为0开始；如果省略了j，默认列表到最后一个元素结束，这里是包括了最后一个元素的。

1.4 列表中其余会用到的操作

操作符或运算符或函数名	功能描述
+	使两个列表连接
*	重复连接列表
in	x在列表中，返回True，否则False
not in	x不在列表中，返回True，否则False
len(列表名)	返回列表的长度
max(列表名)	返回列表中最大元素值
min(列表名)	返回列表中最小元素值
sorted(列表名,reverse=False/True)	返回排好序的新列表
reversed(列表名)	返回一个对列表进行逆序操作后的迭代器，需用list(reversed(列表名))形式转换为列表
sum(列表名)	若列表中均为数值型元素，返回累加和

下面是我对这些操作符或函数的实验:

>>> list1 = [1,2,3,4]
>>> list2 = [5,6,7]
>>> list3 = list1+list2
>>> list3
[1, 2, 3, 4, 5, 6, 7]
>>> list4 = list2*3
>>> list4
[5, 6, 7, 5, 6, 7, 5, 6, 7]
>>> 3 in list1
True
>>> 10 in list2
False
>>> 10 not in list2
True
>>> len(list1)
4
>>> max(list1)
4
>>> min(list2)
5
>>> sorted(list4,reverse=False)
[5, 5, 5, 6, 6, 6, 7, 7, 7]
>>> sorted(list4,reverse=True)
[7, 7, 7, 6, 6, 6, 5, 5, 5]
>>> reversed(list1)
<list_reverseiterator object at 0x000001D691816550>
>>> list(reversed(list1))
[4, 3, 2, 1]
>>> sum(list2)
18

2. 元组

元组可以看作是一组固定的列表，元组创建后，不能对其进行修改，即不能修改元组中的元素值，不能增加和删除元素。元组使用与一旦确定不再变化的批量数据处理。

2.1 创建元组

创建元组的语法格式如下：

方法1：元组名 = (值1,值2,值3,......,值n)
方法2：使用tuple()函数创建，元组名 = tuple(内容)
方法3：元组名 = (表达式 for 变量 in 序列)

下面是对元组的创建进行的实验：

>>> tuple1 = (1,2,3,)
>>> tuple1
(1, 2, 3)
#只有一个元素的元组，元素值后面要跟有逗号，否则会被认为是一个表达式
>>> tuple2 = (1)
>>> tuple2
1
>>> type(tuple2)
<class 'int'>
>>> tuple2 = (1,)
>>> tuple2
(1,)
>>> type(tuple2)
<class 'tuple'>
>>> tuple2 = ("程序设计")
>>> tuple2
'程序设计'
>>> type(tuple2)
<class 'str'>
>>> tuple2 = tuple("程序设计")
>>> tuple2
('程', '序', '设', '计')
>>> tuple2 = ("程序设计", )
>>> tuple2
('程序设计',)
>>> type(tuple2)
<class 'tuple'>
#这里的输出与列表是不一样的，需要通过tuple()函数将值显化
>>> tuple3 = (i-1 for i in range(10))
>>> tuple3
<generator object <genexpr> at 0x0000016A5BA56F68>
>>> tuple(tuple3)
(-1, 0, 1, 2, 3, 4, 5, 6, 7, 8)

2.2 访问元组

元组元素地访问与列表元素地访问相类似，其语法格式如下：

元组名[索引值]

具体实验如下：

>>> tuple1 = tuple(i+1 for i in range(20))
>>> tuple1
(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)
>>> tuple1[3]
4
>>> tuple1[1:5:2]
(2, 4)
>>> tuple1[-1:-10:-3]
(20, 17, 14)
>>> tuple1[-1:-3]  #
()
>>> tuple1[-1]
20
>>> tuple1[-1::-5]
(20, 15, 10, 5)
>>> tuple1[::-6]
(20, 14, 8, 2)
>>> tuple1[-1:-2]  #
()
>>> tuple1[:-3]
(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17)
>>> tuple1[-1:-5]  #
()

2.3 其他操作

通过实验来了解可以通过哪些函数来改变元组：

#可以通过两个元组的相加来改变元组内部的元素数量
>>> tu1 = (1,2,5,3)
>>> tu2 = (1,7,23,0)
>>> tu3 = tu1+tu2
>>> tu3
(1, 2, 5, 3, 1, 7, 23, 0)
#用乘法来将元组中的元素值赋值多少遍
>>> tu4 = tu1*2
>>> tu4
(1, 2, 5, 3, 1, 2, 5, 3)
#元组中若全是数值，返回累加和
>>> sum(tu4)
22
>>> tu7 = ("小张",19,"大二")
>>> sum(tu7)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'str'
#list()函数是会返回一个列表，并将元组变成列表，列表可进行对元素进行更新
>>> tu5 = list(tu1)
>>> tu5
[1, 2, 5, 3]
>>> tu5 = list(reversed(tu1))
>>> tu5
[3, 5, 2, 1]
>>> type(tu5)
<class 'list'>
>>> tu5.insert(10,0)
>>> tu5
[3, 5, 2, 1, 0]
#使用tuple()函数后，只是输出元组，但并未将列表变成元组
>>> tuple(tu5)
(3, 5, 2, 1, 0)
>>> type(tu5)
<class 'list'>
>>> tu5.insert(0,10)
>>> tu5
[10, 3, 5, 2, 1, 0]
#使用sorted()函数可以对元组进行排序
>>> tu6 = sorted(tu3,reverse=True)
>>> tu6
[23, 7, 5, 3, 2, 1, 1, 0]
>>> tu6 = sorted(tu3,reverse=False)
>>> tu6
[0, 1, 1, 2, 3, 5, 7, 23]

元组所涉及到的操作符或函数与列表均有类似的功能，元组与列表的主要区别便是元组不可变，列表可以变。

3. 字典

由于使用列表或元组在一批数据中查找或读取某个数据元素，我们需要知道该元素的索引值，但记住索引值不是一件容易的事。通过字典，我们可以通过关键字来查找或读取批量数据中的信息。

3.1 创建字典

创建字典的语法格式如下：

方法1：字典名 = {键1:值1,键2:值2,...,键n:值n}
方法2：使用dict()函数来创建字典，字典名 = dict(内容)
方法3：推导式创建字典

下面是我进行的一些实验：

>>> dict1 = {
    
    "数学":89,"语文":79,"英语":80}
>>> dict1
{
    
    '数学': 89, '语文': 79, '英语': 80}
>>> dict2 = dict(["数学",78])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: cannot convert dictionary update sequence element #1 to a sequence
>>> dict2 = dict([["数学",78]])
>>> dict2
{
    
    '数学': 78}
>>> dict3 = dict([["数学",80],["英语",79]])
>>> dict3
{
    
    '数学': 80, '英语': 79}
>>> dict4 = {
    
    i:i*i for i in range(10,30,4)}
>>> dict4
{
    
    10: 100, 14: 196, 18: 324, 22: 484, 26: 676}

3.2 访问字典

访问字典的语法格式如下：

字典名[键]

字典与列表、元组不同的是，它是一个无序序列，其中的元素没有对应的索引值。下面是我针对字典元素的访问的实验：

>>> dict1 = {
    
    "数学":88,"英语":78,"语文":89,"计算机":90}
>>> dict1
{
    
    '数学': 88, '英语': 78, '语文': 89, '计算机': 90}
>>> dict1[1]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 1
>>> dict1["数学"]
88

3.3 更新字典

可以通过增加字典元素、删除字典元素、修改元素值、删除字典等角度对字典进行更新。

3.3.1 增加元素与修改元素值

对于增加字典元素与修改字典中元素值的方法有下面这几种格式：

方法1：字典名[键] = 值
方法2：使用setdefault()函数，即字典名.setdefault(键,值)
方法3：使用update()函数，即字典名1.update(字典名2)

• 第一种方法是通过使用赋值语句对字典中的元素进行修改或增加元素；
• 前两种方法中，如果在字典中没有找到指定的"键"，则会将该"键-值"对增加到字典中，如果能找到指定的"键"，则会修改对应的"值"；
• 第三种方法是对字典进行合并，如果两个字典的"键"没有相同的，则将字典2中的元素添加到字典1中，如果有相同的，则用字典2中的值修改字典1中对应的元素值。

下面是我对这三种格式进行的实验：

>>> dict1 = {
    
    "数学":88,"英语":78,"语文":89,"计算机":90}
>>> dict1
{
    
    '数学': 88, '英语': 78, '语文': 89, '计算机': 90}
>>> dict1["物理"] = 79
>>> dict1
{
    
    '数学': 88, '英语': 78, '语文': 89, '计算机': 90, '物理': 79}
>>> dict1["数学"] = 80
>>> dict1
{
    
    '数学': 80, '英语': 78, '语文': 89, '计算机': 90, '物理': 79}
>>> dict1.setdefault("统筹",29)
29
>>> dict1
{
    
    '数学': 80, '英语': 78, '语文': 89, '计算机': 90, '物理': 79, '统筹': 29}
>>> dict1.update(dict2)
>>> dict1
{
    
    '数学': 80, '英语': 10, '语文': 89, '计算机': 90, '物理': 79, '统筹': 29, '电工': 77}

3.3.2 删除元素与删除字典

有下面三种方法可以实现删除字典元素与删除字典：

方法1：del 字典名[键] / del 字典名
方法2：del(字典名[键])          #此处是使用del()函数的方法
方法3：字典名.pop(键,值)

实验如下：

>>> dict1 = {
    
    "name":"李四","sex":"男","age":19}
>>> dict1
{
    
    'name': '李四', 'sex': '男', 'age': 19}
>>> del dict1["name"]
>>> dict1
{
    
    'sex': '男', 'age': 19}
>>> del dict1
>>> dict1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'dict1' is not defined
>>> dict1 = {
    
    "name":"张三","sex":"男","age":29}
>>> dict1
{
    
    'name': '张三', 'sex': '男', 'age': 29}
>>> del(dict1["name"])
>>> dict1
{
    
    'sex': '男', 'age': 29}
>>> dict1.pop("sex","男")
'男'
>>> dict1
{
    
    'age': 29}
>>> dict1.setdefault("name","李四")
'李四'
>>> dict1
{
    
    'age': 29, 'name': '李四'}
>>> dict1.pop("name","张三")
'李四'
>>> dict1
{
    
    'age': 29}
>>> del(dict1)
>>> dict1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'dict1' is not defined

3.4 其他操作的函数和方法

函数/方法	功能描述
字典名.keys()	返回指定字典中所有的"键"
字典名.values()	返回指定字典中所有的"值"
字典名.items()	返回指定字典中的所有"键-值"对
字典名.get(键，默认值)	若存在与"键"相同的"键"，则返回相应的值，否则返回默认值
字典名.popitem()	随机从字典中取出一个"键-值"对，以元组(键,值)形式返回，并删除该"键-值"对
字典名.clear()	删除指定字典的所有"键-值"对，变为空字典
键 in 字典名	存在该"键"，返回True，否则返回False

下面是对上述这几种函数进行的实验：

>>> dict1 = {
    
    "数学":88,"语文":79,"英语":77,"计算机":89}
>>> dict1
{
    
    '数学': 88, '语文': 79, '英语': 77, '计算机': 89}
>>> dict1.keys()
dict_keys(['数学', '语文', '英语', '计算机'])
>>> dict1.values()
dict_values([88, 79, 77, 89])
>>> dict1.items()
dict_items([('数学', 88), ('语文', 79), ('英语', 77), ('计算机', 89)])
>>> dict1.get("数学",10)
88
>>> dict1.get("物理",10)
10
>>> "数学" in dict1
True
>>> "物理" in dict1
False
>>> dict1.popitem()
('计算机', 89)
>>> dict1
{
    
    '数学': 88, '语文': 79, '英语': 77}
>>> dict1.clear()
>>> dict1
{
    
    }

4. 集合

4.1 创建集合

有下面两种方式可以创建集合：

方法1：集合名 = {元素1, 元素2, ... ,元素n}
方法2：集合名 = set(列表或元组)

下面是对创建集合的两种方法的实验：

>>> set1 = {
    
    0,1,2,3,4}
>>> set1
{
    
    0, 1, 2, 3, 4}
>>> set2 = {
    
    ("语文",80),("数学",88),("英语",79)}
>>> set2
{
    
    ('语文', 80), ('英语', 79), ('数学', 88)}
>>> set3 = set([1,2,3,4])
>>> set3
{
    
    1, 2, 3, 4}
>>> set4 = set((2,3,4,5))
>>> set4
{
    
    2, 3, 4, 5}
>>> set5 = set(i for i in range(10))
>>> set5
{
    
    0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
#集合与列表、元组的不同，有重复元素只保留一个元素
>>> set6 = set([1,1,1,3,2,2,3])
>>> set6
{
    
    1, 2, 3}
>>> list1 = list((1,1,1,3,2,2,3))
>>> list1
[1, 1, 1, 3, 2, 2, 3]
>>> tuple1 = tuple((1,1,1,3,2,2,3))
>>> tuple1
(1, 1, 1, 3, 2, 2, 3)

4.2 访问集合

访问集合，不能像列表与元组一样采用索引值进行访问元素，也不能像字典一样通过“键”来访问元素，集合只能通过遍历所有元素来访问。
下面是我对访问集合元素尝试的一个小例子：

score_set = {
    
    ("语文",80),("英语",89),("数学",90)}
print("数学成绩是多少:")
for item in score_set:
	if (item[0] == "数学"):
		print(item[1])
	else:
		continue

4.3 更新集合

4.3.1 增加元素

有两种方式可以增加集合中的元素：

方法1：集合名.add(值)
方法2：集合名.update(集合2)

下面是对这两种方法的实验：

>>> set1 = {
    
    2,3,4,5}
>>> set1
{
    
    2, 3, 4, 5}
>>> set1.add(0)
>>> set1
{
    
    0, 2, 3, 4, 5}
#add()函数中只能放一个元素
>>> set1.add(1,6)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: add() takes exactly one argument (2 given)
>>> set1.add(1)
>>> set1
{
    
    0, 1, 2, 3, 4, 5}
>>> set1.add(10)
>>> set1
{
    
    0, 1, 2, 3, 4, 5, 10}
>>> set1.add([7,8])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
>>> set1.add((7,8))
>>> set1
{
    
    0, 1, 2, 3, 4, 5, 10, (7, 8)}
#下面是对update()函数的实验
>>> set1 = {
    
    1,2,3,4}
>>> set2 = {
    
    0,1,2,6,7}
>>> set1.update(set2)   #等价于set1.update({0,1,2,6,7})
>>> set1
{
    
    0, 1, 2, 3, 4, 6, 7}
>>> set1.add(10)
>>> set1
{
    
    0, 1, 2, 3, 4, 6, 7, 10}
>>> set2.update(set1)
>>> set2
{
    
    0, 1, 2, 3, 4, 6, 7, 10}

4.3.2 删除元素

有四种方式可以将集合中的元素删除：

方法1：集合名.remove(元素值)
方法2：集合名.discard(元素值)
方法3：集合名.pop()
方法4：集合名.clear()

对上述的这四种删除元素的方法进行实验：

>>> set1 = set(i for i in range(15))
>>> set1
{
    
    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}
#若在remove()函数中设定的值是集合中没有的值会报错
>>> set1.remove()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: remove() takes exactly one argument (0 given)
>>> set1.remove(19)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 19
>>> set1.remove(8)
>>> set1
{
    
    0, 1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 12, 13, 14}
#discard()函数与remove()函数作用相类似，但若给出的值是集合中没有的，并不会报错
>>> set1.discard()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: discard() takes exactly one argument (0 given)
>>> set1.discard(19)
>>> set1
{
    
    0, 1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 12, 13, 14}
>>> set1.discard(3)
>>> set1
{
    
    0, 1, 2, 4, 5, 6, 7, 9, 10, 11, 12, 13, 14}
#pop()函数是从集合中随机删除一个元素，这个删除的元素会被作为函数的返回值
>>> set1.pop()
0
>>> set1
{
    
    1, 2, 4, 5, 6, 7, 9, 10, 11, 12, 13, 14}
>>> set1.pop()
1
#clear()函数将集合中的所有元素删除，得到空集合
>>> set1.clear()
>>> set1
set()

5. 字符串

定义一串字符串一般会采用两种方法，即直接赋值与用input()函数输入；而访问字符串也有两种方式，即索引方式与切片方式，这两种方式在访问列表中也有提到过；下面主要从两个方面讲一讲字符串，即字符串的运算与格式设置。

5.1 字符串的运算

在这一节中我会从字符串运算符、字符串运算函数、字符串处理方法这三方面去了解字符串中会用到的方法。

5.1.1 字符串运算符

运算符	功能描述
+	str1+str2：两个字符串连接
*	n *str1：字符串自身连接n次
in	str1 in str2：str1是str2的子串
not in	str1 not in str2：str1不是str2的子串
<,<=,>,>=,==,!=	str1<str2：str1小于str2；其他类似于此

对上面涉及到的五类运算符进行实验：

>>> str1 = "12345"
>>> str2 = "012"
>>> str1+str2
'12345012'
>>> str1*2
'1234512345'
>>> str1 in str2
False
>>> str2 in str1
False
>>> str1 not in str2
True
>>> str2 = "345"
>>> str2 not in str1
False
>>> str2 in str1
True
>>> str1<str2
True
>>> str1<=str2
True
>>> str1 == str2
False
>>> str1 != str2
True

5.1.2 字符串运算函数

函数名	功能描述
len(字符串)	len(str1)：返回字符串str1的长度
str(数值)	str(x)：返回x对应的字符串，可带正负号
chr(编码值)	chr(n)：返回编码值n对应的字符
ord(字符)	ord©：返回字符c对应的编码值

下面是对上述的这四种函数进行的实验：

>>> str1 = "12345"
>>> str2 = "012"
>>> len(str1)
5
>>> len(str2)
3
>>> str(9876)
'9876'
>>> str(-67)
'-67'
>>> str(+12)
'12'
>>> chr(1)
'\x01'
>>> chr(65)
'A'
>>> ord('C')
67
>>> ord('!')
33

5.1.3 字符串处理方法

Python是一种面向对象程序设计语言，它把每种数据类型都封装为一个类，在类内会提供若干函数，这种函数称为“方法”。下面是内置的字符串常用的处理方法。

方法名(函数名)	功能描述
str1.lower()	将str1中的所有英文字符转换为小写作为返回值
str1.upper()	将str1中的所有英文字符转换为大写作为返回值
str1.capitalize()	将str1中的首字母转换为大写作为返回值
str1.title()	将str1中每个单词的首字母转换为大写作为返回值
str1.replace(s1,s2,n)	将str1中的s1子串替换为s2,若没有给出n选项则替换所有s1子串；若有n选项，则替换前n个s1子串
str1.split(sep,n)	将str1分解为一个列表，sep为分隔符(默认是空格)，n为分解出的子串个数，默认是所有子串
str1.find(str2)	若str2是str1的子串，返回str2在str1中的开始位置，否则返回-1
str1.count(str2)	返回str2在str1中出现的次数
str1.isnumeric()	若str1中字符都是数字字符，返回True，否则返回False
str1.isalpha()	若str1中的字符都是字母或汉字，返回True，否则返回False
str1.isupper()	若str1中字母都是大写，返回True，否则返回False
str1.islower()	若str1中字母都是小写，返回True，否则返回False
str1.format()	对str1进行格式设置

下面是实验：

>>> str1 = "PYTHon"
>>> str1.lower()
'python'
>>> str1
'PYTHon'
>>> str1.upper()
'PYTHON'
>>> str1
'PYTHon'
>>> str1 = "python"
>>> str1.capitalize()
'Python'
>>> str1
'python'
>>> str1 = "learn python"
>>> str1.title()
'Learn Python'
>>> str1
'learn python'
>>> str1.replace('n','o',1)
'learo python'
>>> str1
'learn python'
>>> str1.replace('n','o')
'learo pythoo'
>>> str1
'learn python'
>>> str1 = "We are learning python"
>>> str1.split(' ',2)
['We', 'are', 'learning python']
>>> str1.split()
['We', 'are', 'learning', 'python']
>>> str1.split('e')
['W', ' ar', ' l', 'arning python']
>>> str1.find('are')
3
>>> str1.find('Are')
-1
>>> str1.count('e')
3
>>> str1.isnumeric()
False
>>> str1.isalpha()
False
>>> str1.isupper()
False
>>> str1.islower()
False
>>> str1.format()
'We are learning python'

5.2 字符串的格式设置

在Python中有两种控制数据输出格式的方法，一种是%格式设置方法，另一种是format()格式设置方法。

5.2.1 %格式设置方法

通过实验来学习这种格式设置方法：

#整数输出
>>> print("输出一个十进制数:%d"%20)
输出一个十进制数:20
>>> print("输出一个十进制数:%d" ,%20)
  File "<stdin>", line 1
    print("输出一个十进制数:%d" ,%20)
                         ^
SyntaxError: invalid syntax
>>> print("输出一个八进制数:%o"%20)
输出一个八进制数:24
>>> print("输出一个八进制数:%3o"%20)
输出一个八进制数: 24
>>> print("输出一个八进制数:%.3o"%20)
输出一个八进制数:024
>>> print("输出一个十六进制数:%x"%20)
输出一个十六进制数:14
#浮点数输出
>>> print("输出一个浮点数:%f"%12.13)  #保留小数点后面六位有效数字
输出一个浮点数:12.130000
>>> print("输出一个浮点数:%.1f"%12.13)
输出一个浮点数:12.1
>>> print("输出一个浮点数:%3.1f"%12.13)
输出一个浮点数:12.1
>>> print("输出一个浮点数:%e"%12.13)  #保留小数点后面六位有效数字，指数形式输出
输出一个浮点数:1.213000e+01
>>> print("输出一个浮点数:%.3e"%12.13)
输出一个浮点数:1.213e+01
>>> print("输出一个浮点数:%g"%12.13)  #在保证六位有效数字的前提下，使用小数方式，否则使用科学计数法
输出一个浮点数:12.13
>>> print("输出一个浮点数:%g"%120987.123456)
输出一个浮点数:120987
>>> print("输出一个浮点数:%g"%12.123456)
输出一个浮点数:12.1235
>>> print("输出一个浮点数:%.3g"%12.123456)
输出一个浮点数:12.1
#字符串输出
>>> print('%s'%'hello world')
hello world
>>> print('20%s'%'hello world')
20hello world
>>> print('%20s'%'hello world')
         hello world
>>> print('%-20s'%'hello world')
hello world
>>> print('%.2s'%'hello world')
he
>>> print('%10.2s'%'hello world')
        he

5.2.2 format()格式设置方法

使用format()方法的语法格式如下：

模板字符串.format(参数表)
其中模板字符串是由字符和一系列槽(用一对大括号表示)组成

示例如下：

>>> print("{}乘以{}等于{}".format(16,3,16*3))
16乘以3等于48

上述例子是对format()格式输出的一种简单例子，为了能够更精准、更严格地输出数据，模板字符串中的槽中可以写入格式控制信息，其格式如下：

{参数序号:格式控制标记}.format(参数表)

格式控制标记可以参考下表：

格式标记	含义
填充	用于满足输出宽度要求需要(参数宽度不满足输出宽度要求)填充的单个字符，默认是空格
对齐	<表示控制左对齐，>表示控制右对齐，^表示控制居中对齐
宽度	设定槽对应的参数值的输出宽度
,	数值的千位分隔符，便于阅读
.精度	浮点数小数部分的保留位数/字符串的最大输出长度
类型	对于整数可选用符号c和d，对于浮点数可选用符号e、E、f、%。其中：c表示输出整数对应的Unicode字符；d表示整数的十进制形式；e表示输出浮点数对应的小写字母e的指数形式；E表示输出浮点数对应的大写字母E的指数形式；f表示输出浮点数的标准浮点形式；%表示输出浮点数的百分比形式

实验如下：

>>> print("{:-^30,}".format(123456789))
---------123,456,789----------
>>> print("{:}".format(6789))
6789
>>> print("{2:*>4}{1:->4}{0:@>4}".format(45678,9876,23451))
23451987645678
>>> print("{2:*>8}{1:->10}{0:@>8}".format(45678,9876,23451))
***23451------9876@@@45678
>>> print("{:5d}".format(32))
   32
>>> print("{:5c}".format(65))
    A
>>> print("{:5d}".format(65))
   65
>>> print("{:10.2f}".format(567.8765))
    567.88
>>> print("{:10.2e}".format(567.8765))
  5.68e+02
>>> print("{:10.2E}".format(567.8765))
  5.68E+02
>>> print("{:10.2%}".format(567.8765))
 56787.65%