Datawhale学习计划：python基础第六期-基础任务2

List（列表）知识：1年级1班的班级生活

1.1 列表是个啥：List（列表）的基础知识：

A.List是啥？

a. List属于序列：序列共有 List 、 Turple 、 字符串 、 Unicode字符串 、 buffer对象 和 xrange对象 六种，所有序列都存在内部的索引（将在后文提及）。

b. List属于标准数据类型：Python标准数据类型共有 Number（数字） 、 String（字符串） 、 List（列表） 、 Turple（元组） 、 Set（集合) 、 Dictionary（字典) 六类。

B.List有啥特征？

我们先来看几个List（序列）长啥样:

>>> a = ['Think','123456','[1,2,3]']

观察可以看到：

a. 序列的基本结构为： 变量 = [ ] ，即 变量 、 = 和 [] 。
b. 序列内的数据类型：不要求一致，可以有多种并存，甚至一个List里面还可以包含其他List。被包含的"子List"此时作为“母List”的元素。
c. 序列内的元素：序列内的内容为元素，元素数目可以为0，即空集 a = [] ；元素之间用 , 分隔开；如果元素为字符串，应用 ’ 或者 " 括起来。

C. 序列可以进行的基本操作：最基础的基本操作一共有五种： 索引 、 切片 、 加 、 乘 、 检查 ，将在后文中进行详细解释。

1.2 可以对列表做啥：List（列表）的操作

a. 创建：1年级1班开学了！

我们假设1年级1班开学了，一共有李布尔、王多鱼、苏大强三名小朋友入学。我们简称1年级1班的班名为 one ，现在我们要打印出这个班级的同学名单：

>>> one = ['李布尔','王多鱼','苏大强']
>>> one
['李布尔', '王多鱼', '苏大强']

用中括号[ ]创建一个列表赋给 one 。当然班级也可以没人，比如隔壁1年级2班没人，list可以是空的：

>>> two = []
>>> two
[]

b. 计数 ：班里有几个人？
这时候老师想知道1年级1班有几个人，三个人很容易数出来，可如果想知道全校的人数呢？需要调用 len(班级名) 这个语句来计数列表内的元素长度（数目）：

>>> one = ['李布尔','王多鱼','苏大强']
>>> len(one)
3

注意：空list也可以用len，空list长度为0。比如我们看看惨淡的1年级2班：

>>> two = []
>>> len(two)
0

c. 访问元素：班里都是按学号点名的！

在学校里，每名同学都有自己的学号，这就是列表中的元素索引。

学号的制定规律：

1.在一个有人的班级中，每名同学都有两个学号（即索引），这个学号是以他们在整个班级中的相对位置确定的。

2.正数第一位学号为 0 ，正数第二位学号为 1 …倒数第一位学号为 -1 ，倒数第二位学号为 -2 。即：正数索引为n-1，倒数索引为-n。

比如以1年级1班为例：

>>> one = ['李布尔','王多鱼','苏大强']

王多鱼是正数第一位同学、倒数第三位同学。所以他的学号就有 0 和 -3 两个。

当老师想点名的时候，要用 班级名[学号] 的方式点学号。例如点二号同学：

>>> one = ['李布尔','王多鱼','苏大强']
>>> one[2]
'苏大强'

如果老师想叫多位同学，比如想叫从1号开始后面的所有同学呢？

>>> one = ['李布尔','王多鱼','苏大强']
>>> one[1:]
['王多雨', '苏大强']

我们可以看到，就成功把1号和2号同学叫出来了。这里用的是切片的方式，即 班级名[从第几号学生开始:截止到第几号学生之前] ，从第n号开始的全部可以用 班级名 [n:] ，截止到n号之前的全部可以用 班级名[:n] 。

d. 追加元素 ：1年级1班的新生
班里转来了一名新生，叫史晓明。我们用 班级名.append(新同学名字) 的方式将他添到班级名单里，按照先来后到的规则，他自然排在最后：

第一种情况：默认添加新元素到列表末尾

>>> one = ['李布尔','王多鱼','苏大强']
>>> one.append('史晓明')
>>> one
['李布尔', '王多鱼', '苏大强', '史晓明']

这时候 ‘王多鱼’ 小朋友家财大气粗的派来一名随读保镖，强烈要求学号和王多鱼挨着。那能不能安排到指定位置呢？当然可以，我们可以使用 班级名.insert(保镖学号,‘保镖名字’) 的方式将其添加到指定位置：

第二种情况：指定位置插入元素

>>> one = ['李布尔', '王多鱼', '苏大强', '史晓明']
>>> one.insert(2,'钱大彪')
>>> one
['李布尔', '王多鱼', '钱大彪', '苏大强', '史晓明']

这时候需要注意，因为 ‘钱大彪’ 的加入，导致列表内新元素后面元素的相对位置都发生了一次变化。例如 ‘苏大强’ 过去学号是 2 和 -2 ，现在学号则变成了 3 和 -2 。

e.删除：报告老师，我想退学！

因为刚才 ‘钱大彪’ 的加入，导致 ‘苏大强’ 和 ‘史晓明’ 的学号都滞后一名。在调和失败后， ‘史晓明’ 同学愤而退学，老师只好将其从班级名单中删掉。在python中，将元素从列表中删除一共有三种方式：

第一种删除方式： remove 语句

班主任拿出了班级名单，找到了 ‘史晓明’ 的名字，然后用 班级名.remove(史晓明的姓名) 的方式将 ‘史晓明’ 在班级名单中删除了：

>>> one = ['李布尔', '王多鱼', '钱大彪', '苏大强', '史晓明']
>>> one.remove('史晓明')
>>> one
['李布尔', '王多鱼', '钱大彪', '苏大强']

第二种删除方式： del 语句

第一种用 remove 语句删除的情况，前提是老师记得 ‘史晓明’ 的名字。但万一老师不知道这个学生的名字，或者有熊孩子没事改名字记不住咋办？没事，我们还可以用他的学号删除（索引删除），方法为： del 班级名[史晓明学号] 。

>>> one = ['李布尔', '王多鱼', '钱大彪', '苏大强', '史晓明']
>>> del one[4]
>>> one
['李布尔', '王多鱼', '钱大彪', '苏大强']

第三种删除方式： pop 语句

我们用学号删除的时候容易出问题，万一删错了咋办？我咋知道哪个索引到底还是不是 ‘史晓明’ 的学号？。这时候我们可以用 pop 语句，同样也是用索引删除，但是pop删除元素后会给你显示删除学号对应的名字。具体方法为： 班级名.pop(史晓明的学号)

>>> one = ['李布尔', '王多鱼', '钱大彪', '苏大强', '史晓明']
>>> one.pop(4)
'史晓明'
>>> one
['李布尔', '王多鱼', '钱大彪', '苏大强']

我们可以看到执行了 班级名.pop(史晓明学号) 后，先给我们返回了一个 ‘史晓明’ 的值，告诉我们刚才删的是啥。我们在执行一下 one ，就会看到班级名单里已经删除了。

注意：当我们需要删除列表中的最后一个元素时，可以不写元素索引。像在刚才的例子中，用 班级名.pop() 即可删除位于班级名单最后的 ‘史晓明’ 同学：

>>> one = ['李布尔', '王多鱼', '钱大彪', '苏大强', '史晓明']
>>> one.pop()
'史晓明'
>>> one
['李布尔', '王多鱼', '钱大彪', '苏大强']

这时候如果我们想再确认一遍 ‘史晓明’ 同学到底还在不在班级名单里，可以使用 in 语句，方法为 要检查的同学名字 in 班级名 ：

>>> one = ['李布尔','王多鱼','钱大彪','苏大强']
>>> '史晓明' in one
False

返回的结果是 False ，就说明史晓明已经不在班级名单中了。同样我们也可以用 要检查的元素 not in 序列 来判断元素是否不再序列中，这里就不举例子了。

**f. 更新与替换：王多鱼改名了

换名的情况还是发生了：有一天 ‘王多鱼’ 的家长联系老师，请老师更新一下班级名单，因为王多鱼刚刚改名了。老师问为啥？他说觉得 ‘王多鱼’ 这个名字太世俗了，要取一个有文化的名字： ‘王有才’ 。

老师虽是无奈，也只好作罢。用 班级名[王多鱼的学号] = 王多鱼的新名字 的方式将班级名单中，王多鱼的姓名记录更新了，从此以后王多鱼叫王有才：

>>> one = ['李布尔', '王多鱼', '钱大彪', '苏大强']
>>> one[1] = '王有才'
>>> one
['李布尔', '王有才', '钱大彪', '苏大强']

**g.合并班级

后来教务处做出一个决定，将1年级3班并入1年级1班。忙碌的班主任又要开始重新合并班级名单，我们先来看一下1年级3班的新同学们：

>>> three = ['杨九年','周媛','钱大彪','郑仕']

（好像有个哥们重名了？？我们一会再说）

班主任这时调用了 extend 语句合并两个班的学生，方法为 1班名字.extend(3班名字)

>>> one = ['李布尔', '王有才', '钱大彪', '苏大强']
>>> three = ['杨九年','周媛','钱大彪','郑仕']
>>> one.extend(three)
>>> one
['李布尔', '王有才', '钱大彪', '苏大强', '杨九年', '周媛', '钱大彪', '郑仕']

还是按照先来后到的道理：extend里新加入列表内的所有元素，都默认添加到了源列表的末尾。
另外我们发现，1年级1班和1年级3班都有1名叫 ‘钱大彪’ 的同学，但是都不受影响的就放到了同一个列表中。我们可得知：列表中的元素是可重复的。

如果有重复，我们咋知道重复了几次呢？这时候我们可以用 ‘count’ 语句，用法为 班级名.count(像检查重复数的对象) ：

>>> one = ['李布尔', '王有才', '钱大彪', '苏大强', '杨九年', '周媛', '钱大彪', '郑仕']
>>> one.count('钱大彪')
2

我们就知道，班里现在有两个 ‘钱大彪’ 的人了，我们可以按照学号次序管他们叫 ‘大钱大彪’ 和 ‘小钱大彪’，我们想查 ‘大钱大彪’ 的学号时，可以用 班级名.index(搜索条件) 的方式检索第一个匹配搜索的同学的学号（序列）：

>>> one = ['李布尔', '王有才', '钱大彪', '苏大强', '杨九年', '周媛', '钱大彪', '郑仕']
>>> one.index('钱大彪')
2

这时候我们就可以快速知道，‘大钱大彪’ 的学号是 2 了。

**h. 排序与嵌套：1年级1班要分组了

为了班级合并后的有序管理，教务处给了1年级1班的班主任一个这样的任务：

1. 要选出一名班长。
2. 班长以外的七名同学分成两组，每组一名队长三名队员。
3. 以学籍号正序为准，前三位分别为：班长、两名队员。
4. 将班长名单、队长名单、队员名单提交至教务处，收到回复。

第一步：选出学籍号排名第一的同学为班长

一开始我们说每个都学都有自己的学号（索引），但是这容易出现这样一个问题：
在1年级1班里，学号为 0 的是 ‘李布尔’ 小朋友，但 ‘杨九年’ 小朋友在3年级1班的时候学号也是 0 。为了避免这种重新排序，我们要了解 学籍号 （id）这个概念，每个小朋友都有自己独一无二id，我们可以用 id(查看id的对象) 这个语句来查看：

>>> one = ['李布尔', '王有才', '钱大彪', '苏大强', '杨九年', '周媛', '钱大彪', '郑仕']
>>> id('苏大强')
2078505060944
>>> id('周媛')
2078503793656

首先要按照学籍号选出班长来。班主任在这时候调用了 min 语句，使用方法为 min(班级名)：

>>> one = ['李布尔', '王有才', '钱大彪', '苏大强', '杨九年', '周媛', '钱大彪', '郑仕']
>>> min(one)
'周媛'

这时，姓名首字母排名最小的 ‘周媛’ 同学成为了班长。

顺便一提：我们看到 min 语句自然而然就能想到 max 语句，使用方法为 max() 语句。

max 和 min 语句其实可以设定排序条件的，方法为 min(班级名,key=排序方式) ，比如我们想看看1年级1班中谁名字最短，就可以用 len 即长度来作为判断标准 min(班级名,key=len) ：

>>> one = ['李布尔', '王有才', '钱大彪', '苏大强', '杨九年', '周媛', '钱大彪', '郑仕']
>>> min(one,key=len)
'周媛'

我们会发现在班里 ‘周媛’ 和 ‘郑仕’ 都是两个字，但是执行后却给了我们 ‘周媛’ 的名字，原因是： min 或者 max 语句默认将符合条件的第一个作为结果返回。

第二步：按学籍号排名先后分出队长和队员

要分出队长和队员，首先我们要知道1年级1班同学们学籍号由小到大的排序吧，班主任用了 sort 语句给班内人排序，使用方法为 班级名.sort() ：

>>> one = ['李布尔', '王有才', '钱大彪', '苏大强', '杨九年', '周媛', '钱大彪', '郑仕']
>>> one.sort()
>>> one
['周媛', '李布尔', '杨九年', '王有才', '苏大强', '郑仕', '钱大彪', '钱大彪']

现在就一目了然了： 次序第一位的 ‘周媛’ 为班长、次序第二、三位的 ‘李布尔’ 、 ‘杨九年’ 为队长， 其余五人各为两组队员。

说到用 sort 语句可以将一个列表正向排列，就不得不提到可以将列表倒叙排列的 reverse 语句：

>>> one = ['周媛', '李布尔', '杨九年', '王有才', '苏大强', '郑仕', '钱大彪', '钱大彪']
>>> one.reverse()
>>> one
['钱大彪', '钱大彪', '郑仕', '苏大强', '王有才', '杨九年', '李布尔', '周媛']

这时候老师可以创建班长、队长、队员的三个名单了：

>>> monitor = ['周媛']
>>> captain = ['李布尔','杨九年' ]
>>> member = [ '王有才', '苏大强', '郑仕', '钱大彪', '钱大彪']

但是这样分三行显示好像不太方便，机智的班主任使用了将 monitor 、 captain 和 member 合并给了一个新的班级名单：

>>> monitor = '周媛'
>>> captain = ['李布尔','杨九年' ]
>>> member = [ '王有才', '苏大强', '郑仕', '钱大彪', '钱大彪']
>>> one = [monitor, captain, member]
>>> one
['周媛', ['李布尔', '杨九年'], ['王有才', '苏大强', '郑仕', '钱大彪', '钱大彪']]

班主任完成了1年级1班开学以来的第一个重要任务，心满意足的给教务处交了差。

通过上述我们可以观察得知：list（列表）内还可以嵌套列表，即列表的元素本身可以是其他列表。

**i. 复制：教务主任想把这次的名单备个份

教务主任想把这次1年级1班提交的班级名单拷贝一份，留在他的备份 Beifen 里，开始纠结起来了：列表（list）的备份方式有 直接赋值 、 浅拷贝 和 深拷贝 三种，这种情况下用哪种好呢？都试试吧！

**第一种拷贝：直接赋值

一开始教务主任想偷偷懒，直接把1年级1班提交的 one 列表赋值给我的备份文件 Beifen 不就好了 ：

>>> one = ['周媛', ['李布尔', '杨九年'], ['王有才', '苏大强', '郑仕', '钱大彪', '钱大彪']]
>>> Beifei = one
>>> Beifei
['周媛', ['李布尔', '杨九年'], ['王有才', '苏大强', '郑仕', '钱大彪', '钱大彪']]

完美！可是直到有一天，教导主任发现他办公室里的那份 Beifen 文件里，怎么 ‘杨九天’ 自己变成了 ‘杨浩天’ ？他去问1年级1班的班主任，班主任告诉他：

杨九天改名了，我就把我手里的班级名单改了，怎么，您那儿的列表也变了？

是的，也改变了：

>>> captain[1] = '杨浩天'
>>> one
[['周媛'], ['李布尔', '杨浩天'], ['王有才', '苏大强', '郑仕', '钱大彪', '钱大彪']]
>>> Beifei
[['周媛'], ['李布尔', '杨浩天'], ['王有才', '苏大强', '郑仕', '钱大彪', '钱大彪']]

教务主任想：这不靠谱啊，这样我办公室文件就可以让提交人随便改了！

于是教导主任只能开始尝试第二种：

**第二种拷贝：浅拷贝

浅拷贝的使用方式主要有 拷贝到的地方 = 源列表.copy() 、 拷贝到的地方 = 源列表[:] 、 拷贝到的地方 = list(源列表) 效果相同的三种，教导主任就以第一种为例试一下：

>>> Beifei = one.copy()
>>> Beifei
[['周媛'], ['李布尔', '杨九天'], ['王有才', '苏大强', '郑仕', '钱大彪', '钱大彪']]

好像看起来又成功了，但教导主任不死心。让班主任再改一下他手里的班级文件，看看自己这里会不会变：

>>> captain[1] = '杨浩天'
>>> one
[['周媛'], ['李布尔', '杨浩天'], ['王有才', '苏大强', '郑仕', '钱大彪', '钱大彪']]
>>> Beifei
[['周媛'], ['李布尔', '杨浩天'], ['王有才', '苏大强', '郑仕', '钱大彪', '钱大彪']]

还是会变！ 教导主任又放弃了第二种拷贝方式，将希望放在了最后一种上：

**第三种拷贝：深拷贝

深拷贝和刚才两种都不一样，使用深拷贝前需要先用 import 语句将 copy 调用出来，方法为 import copy 。调用后，深拷贝的使用方法为 拷贝到的地方 = copy.deepcopy(源列表) ：

>>> import copy
>>> Beifei = copy.deepcopy(one)
>>> Beifei
[['周媛'], ['李布尔', '杨九天'], ['王有才', '苏大强', '郑仕', '钱大彪', '钱大彪']]

失败了两次的教务主任这时候已经不信结果了，执意要班主任再在他那改一次名字：

>>> captain[1]= '杨浩天'
>>> one
[['周媛'], ['李布尔', '杨浩天'], ['王有才', '苏大强', '郑仕', '钱大彪', '钱大彪']]
>>> Beifei
[['周媛'], ['李布尔', '杨九天'], ['王有才', '苏大强', '郑仕', '钱大彪', '钱大彪']]

成功了！这时候我们就明白了：在深拷贝中，当改变原序列中二层以及二层以下的内容时，拷贝后的内容不会受到任何影响。而直接赋值和浅拷贝的方式会受影响。

啥叫二层？

#这叫只有一层：
first = []
#这叫二层，存在列表嵌套
second = [[],[]]

到这里，我们关于list（列表）的叙述就告一段落。

2. 元组（Turple）

1.1 标志

a .Turple与List的异同：Turple和List都是Python中内置的序列类型，这种类型一共有6种，在2.元组 (Turple)中我们讲Turple。在外观上，List 用 [] 创建，Turple 用 () 创建。

b. 序列的索引：同List一样，序列内的每个元素都有一个位置索引，第一个元素索引为0，最后一个元素索引为-1。即：正数索引为n-1，倒数索引为-n。

2.2 基本操作（创建及不可变）

刚才我们了解完 List 后，其实理解 Turple 就很轻松了。List 中很多操作在 Turple 中都是通用的，不过也存在几点需要特别注意的：

a.创建 Turple 时，用 () 创建，而不是像 List 一样用 [] ：

>>> a = ('周媛','李布尔')
>>> a
('周媛', '李布尔')

b, 当元组内只包含一个元素时，需要在该元素后边打上一个： , 。不然看起来与字符串无异。我们在python内判断数据类型时，可以用 type(需要判断的对象) 来判断：

>>> a1 = ('王有才')
>>> a2 = ('王有才',)
>>> type(a1)
<class 'str'>
>>> type(a2)
<class 'tuple'>

我们可以看到， (‘王有才’) 是一个 Str（字符串），而 (‘王有才’,) 才是一个 Turple（元组）。

c. 不可变性：Turple很傲娇，是不允许修改的！

不允许修改意味着：元组一旦创建，元组内的所有元素不能更新、不能替换、不能删除，同时这意味着 Turple 稳定性和安全度很高。

d. 元组本身不可改，但是可以通过赋给新的元组的方式’再造":

>>> a = ('王有才','钱大彪')
>>> b = ('苏大强',)
>>> a = a + b
>>> a
('王有才', '钱大彪', '苏大强')

3. 字符串（string）

3.1 定义及基本操作

a. 字符串定义：
字符串是 Python 中最常用的数据类型。我们可以使用引号( ’ 或 " )来创建字符串。

b .创建字符串
创建字符串很简单，只要为变量分配一个值即可。例如：

>>> one = ‘1年级1班’
>>> two = "1年级2班"

c. 字符串的加与乘

我们可以通过 字符串+字符串 或者 字符串*倍数 来对字符串进行简单操作：

>>> a = 'data'
>>> b = 'whale'
>>> a+b
'datawhale'
>>> (a+b)*3
'datawhaledatawhaledatawhale'

d. 访问字符串中的值

对字符串内的值，我们可以用方括号 [] 进行截取，用法为 字符串[从哪个索引开始:截止到哪个索引之前] 。注意：引号后的索引为”截止到…之前“，比如 a[2:5] 就是截取的 a 中序列为2、3、4的内容：

>>> a = 'datawhale'
>>> a[2:5]
'taw'

e. 字符串的更新

字符串可以截取字符串的一部分并与其他字段拼接，比如：

>>> a = 'WelcometoPython'
>>> print (a[:9]+'Datawhle')
WelcometoDatawhle

注意：如果是从第一个字符串开始，则可以省略冒号前面的数字；如果是截止到最后，则可以省略冒号后面的数字。比如刚才我需要截取 ‘WelcometoPython’ 的 ‘Welcometo’ 。我是从第一位开始截取的，所以引号前的数字我可以空着；我就需要截至到第 9 位 ‘ P ’，所以引号后的数字为 9 ，所以就是 [:9] 。

f. 字符串的转义符

因为字符串外边需要通过引号( ’ 或 " )来创建，所以当字符串内部出现 ’ 或 " 的时候，会造成结构混乱无法识别。这时候就需要 转义符 \ 来解决问题。

在 ’ 或 " 的前面加上 \ ，例如：

>>> thing = 'I\'m good.'
>>> print(thing)
I'm good.

3.2 字符串相关方法

a. 转换：

将字符串的第一个字符转换为大写： capitalize()

大写转换为小写，小写转换为大写： swapcase()

所有小写字母转化为大写： upper()

所有大写字母转化为小写： lower()

# 将字符串的第一个字符转换为大写
>>> a = 'thinking' 
>>> print(a.capitalize())
>>> Thinking

#大写转换为小写，小写转换为大写
>>> a = 'Thinking' 
>>> print(a.swapcase())
>>> tHINKING

#所有小写字母转化为大写
>>> a = 'Thinking' 
>>> print(a.upper())
>>> THINKING

#所有大写字母转化为小写
>>> a = 'THINKING'
>>> print(a.lower())
>>> thinking

b. 修改：
删除字符串字符串末尾的空格： rstrip()

>>> a = 'thinking   '
>>> a
'thinking   '
>>> a.rstrip()
'thinking'

c. 访问
返回字符串 str 中最大的字母： max()

返回字符串 str 中最小的字母： min()

返回字符串长度： len(字符串)

统计字符串里某个字符出现的次数： 字符串.count(要统计的字符,(开始搜索的位置索引,结束搜索的位置索引))

>>> a = 'thinking'
>>> #返回字符串 str 中最大的字母
>>> max(a)
't'	

>>> #返回字符串 str 中最小的字母
>>> min(a)
'g' 

>>> #返回字符串长度
>>> len(a)
8 

>>> #统计字符串里某个字符出现的次数
>>> a.count('i')
2 

d. 判断（返回布尔值）

如果字符串中只包含空白，则返回 True，否则返回 False： isspace()

如果字符串中只包含数字字符，则返回 True，否则返回 False： isnumeric()

如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False： isalpha()

检查所有字母都是小写，是则返回 True，否则返回 False： islower()

检查所有字母都是小写，是则返回 True，否则返回 False： isupper()

>>> # 如果字符串中只包含空白，则返回 True，否则返回 False：
>>> a = ''
>>> a.isspace()
True

>>> # 如果字符串中只包含数字字符，则返回 True，否则返回 False：
>>> a = '123py'
>>> a.isnumeric()
False

>>> # 如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False：
>>>> a = '123py'
>>> a.isalpha()
False

>>> # 检查所有字母都是小写，是则返回 True，否则返回 False：
>>> a = 'think'
>>> a.isupper()
True

>>> # 检查所有字母都是小写，是则返回 True，否则返回 False：
>>> a = 'Think'
>>> a.islower()
False

4. 字符串格式化问题

所谓”格式化“，就是让字符串可以有格式的输出。最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中：

>>> print ("今天是 %d 年 %d 月 %d 日" % (2019,4,3))
>>> 今天是 2019 年 4 月 3 日

关于字符串的格式化符号有很多，见下表：

参考资料：
http://www.runoob.com/
https://blog.csdn.net/weixin_44025803/article/details/88922461
https://blog.csdn.net/firtslei/article/details/80213127
https://www.cnblogs.com/854594834-YT/p/10463574.html
https://blog.csdn.net/u012501054/article/details/78957631
http://www.runoob.com/python/python-func-id.html
http://www.runoob.com/python/att-list-index.html
http://www.runoob.com/python3/python3-string-max.html
https://blog.csdn.net/wy_bk/article/details/84994739
http://www.runoob.com/python/python-lists.html
https://jingyan.baidu.com/article/a65957f4295c0f24e77f9b51.html