建站
咨询
售后
建站咨询
python字典操作函数
字典是一种通过名字或者关键字引用的得数据结构，其键可以是数字、字符串、元组，这种结构类型也称之为映射。字典类型是Python中唯一内建的映射类型，基本的操作包括如下：
吉林网站建设公司创新互联公司,吉林网站设计制作，有大型网站制作公司丰富经验。已为吉林上1000+提供企业网站建设服务。企业网站搭建\成都外贸网站建设要多少钱，请找那个售后服务好的吉林做网站的公司定做！
(1)len()：返回字典中键—值对的数量；
(2)d[k]:返回关键字对于的值；
(3)d[k]=v:将值关联到键值k上；
(4)del d[k]:删除键值为k的项；
(5)key in d:键值key是否在d中，是返回True，否则返回False。
(6)clear函数：清除字典中的所有项
(7)copy函数：返回一个具有相同键值的新字典；deepcopy()函数使用深复制，复制其包含所有的值，这个方法可以解决由于副本修改而使原始字典也变化的问题
(8)fromkeys函数：使用给定的键建立新的字典，键默认对应的值为None
(9)get函数：访问字典成员
(10)has_key函数：检查字典中是否含有给出的键
(11)items和iteritems函数:items将所有的字典项以列表方式返回，列表中项来自（键，值），iteritems与items作用相似，但是返回的是一个迭代器对象而不是列表
(12)keys和iterkeys：keys将字典中的键以列表形式返回，iterkeys返回键的迭代器
(13)pop函数：删除字典中对应的键
(14)popitem函数：移出字典中的项
(15)setdefault函数：类似于get方法，获取与给定键相关联的值，也可以在字典中不包含给定键的情况下设定相应的键值
(16)update函数：用一个字典更新另外一个字典
(17) values和itervalues函数：values以列表的形式返回字典中的值，itervalues返回值得迭代器，由于在字典中值不是唯一的，所以列表中可以包含重复的元素
一、字典的创建
1.1 直接创建字典
d={'one':1,'two':2,'three':3}
printd
printd['two']
printd['three']
运算结果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
1.2 通过dict创建字典
# _*_ coding:utf-8 _*_
items=[('one',1),('two',2),('three',3),('four',4)]
printu'items中的内容:'
printitems
printu'利用dict创建字典，输出字典内容:'
d=dict(items)
printd
printu'查询字典中的内容:'
printd['one']
printd['three']
运算结果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
items中的内容:
[('one',1), ('two',2), ('three',3), ('four',4)]
利用dict创建字典，输出字典内容:
{'four':4,'three':3,'two':2,'one':1}
查询字典中的内容:
或者通过关键字创建字典
# _*_ coding:utf-8 _*_
d=dict(one=1,two=2,three=3)
printu'输出字典内容:'
printd
printu'查询字典中的内容:'
printd['one']
printd['three']
运算结果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
输出字典内容:
{'three':3,'two':2,'one':1}
查询字典中的内容:
二、字典的格式化字符串
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3,'four':4}
printd
print"three is %(three)s."%d
运算结果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'four':4,'three':3,'two':2,'one':1}
threeis3.
三、字典方法
3.1 clear函数：清除字典中的所有项
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3,'four':4}
printd
d.clear()
printd
运算结果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'four':4,'three':3,'two':2,'one':1}
{}
请看下面两个例子
3.1.1
# _*_ coding:utf-8 _*_
d={}
dd=d
d['one']=1
d['two']=2
printdd
d={}
printd
printdd
运算结果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'two':2,'one':1}
{}
{'two':2,'one':1}
3.1.2
# _*_ coding:utf-8 _*_
d={}
dd=d
d['one']=1
d['two']=2
printdd
d.clear()
printd
printdd
运算结果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'two':2,'one':1}
{}
{}
3.1.2与3.1.1唯一不同的是在对字典d的清空处理上，3.1.1将d关联到一个新的空字典上，这种方式对字典dd是没有影响的，所以在字典d被置空后，字典dd里面的值仍旧没有变化。但是在3.1.2中clear方法清空字典d中的内容，clear是一个原地操作的方法，使得d中的内容全部被置空，这样dd所指向的空间也被置空。
3.2 copy函数：返回一个具有相同键值的新字典
# _*_ coding:utf-8 _*_
x={'one':1,'two':2,'three':3,'test':['a','b','c']}
printu'初始X字典：'
printx
printu'X复制到Y：'
y=x.copy()
printu'Y字典：'
printy
y['three']=33
printu'修改Y中的值，观察输出：'
printy
printx
printu'删除Y中的值，观察输出'
y['test'].remove('c')
printy
printx
运算结果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
初始X字典：
{'test': ['a','b','c'],'three':3,'two':2,'one':1}
X复制到Y：
Y字典：
{'test': ['a','b','c'],'one':1,'three':3,'two':2}
修改Y中的值，观察输出：
{'test': ['a','b','c'],'one':1,'three':33,'two':2}
{'test': ['a','b','c'],'three':3,'two':2,'one':1}
删除Y中的值，观察输出
{'test': ['a','b'],'one':1,'three':33,'two':2}
{'test': ['a','b'],'three':3,'two':2,'one':1}
注：在复制的副本中对值进行替换后，对原来的字典不产生影响，但是如果修改了副本，原始的字典也会被修改。deepcopy函数使用深复制，复制其包含所有的值，这个方法可以解决由于副本修改而使原始字典也变化的问题。
# _*_ coding:utf-8 _*_
fromcopyimportdeepcopy
x={}
x['test']=['a','b','c','d']
y=x.copy()
z=deepcopy(x)
printu'输出：'
printy
printz
printu'修改后输出：'
x['test'].append('e')
printy
printz
运算输出：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
输出：
{'test': ['a','b','c','d']}
{'test': ['a','b','c','d']}
修改后输出：
{'test': ['a','b','c','d','e']}
{'test': ['a','b','c','d']}
3.3 fromkeys函数：使用给定的键建立新的字典，键默认对应的值为None
# _*_ coding:utf-8 _*_
d=dict.fromkeys(['one','two','three'])
printd
运算输出：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':None,'two':None,'one':None}
或者指定默认的对应值
# _*_ coding:utf-8 _*_
d=dict.fromkeys(['one','two','three'],'unknow')
printd
运算结果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':'unknow','two':'unknow','one':'unknow'}
3.4 get函数：访问字典成员
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
printd.get('one')
printd.get('four')
运算结果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
1
None
注：get函数可以访问字典中不存在的键，当该键不存在是返回None
3.5 has_key函数：检查字典中是否含有给出的键
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
printd.has_key('one')
printd.has_key('four')
运算结果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
True
False
3.6 items和iteritems函数:items将所有的字典项以列表方式返回，列表中项来自（键，值），iteritems与items作用相似，但是返回的是一个迭代器对象而不是列表
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
list=d.items()
forkey,valueinlist:
printkey,':',value
运算结果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
three :3
two :2
one :1
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
it=d.iteritems()
fork,vinit:
print"d[%s]="%k,v
运算结果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
d[three]=3
d[two]=2
d[one]=1
3.7 keys和iterkeys：keys将字典中的键以列表形式返回，iterkeys返回键的迭代器
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
printu'keys方法：'
list=d.keys()
printlist
printu'\niterkeys方法：'
it=d.iterkeys()
forxinit:
printx
运算结果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
keys方法：
['three','two','one']
iterkeys方法：
three
two
one
3.8 pop函数：删除字典中对应的键
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
d.pop('one')
printd
运算结果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
{'three':3,'two':2}
3.9 popitem函数：移出字典中的项
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
d.popitem()
printd
运算结果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
{'two':2,'one':1}
3.10 setdefault函数：类似于get方法，获取与给定键相关联的值，也可以在字典中不包含给定键的情况下设定相应的键值
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
printd.setdefault('one',1)
printd.setdefault('four',4)
printd
运算结果：
{'three':3,'two':2,'one':1}
{'four':4,'three':3,'two':2,'one':1}
3.11 update函数：用一个字典更新另外一个字典
# _*_ coding:utf-8 _*_
d={
'one':123,
'two':2,
'three':3
}
printd
x={'one':1}
d.update(x)
printd
运算结果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':123}
{'three':3,'two':2,'one':1}
3.12 values和itervalues函数：values以列表的形式返回字典中的值，itervalues返回值得迭代器，由于在字典中值不是唯一的，所以列表中可以包含重复的元素
# _*_ coding:utf-8 _*_
d={
'one':123,
'two':2,
'three':3,
'test':2
}
printd.values()
运算结果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
[2,3,2,123]
Python 数据处理（三十五）—— 文本数据处理
在 pandas 中，存储文本主要有两种方式
但一般建议使用 StringDtype 类型存储文本数据。都是由于各种原因，现在字符串数据的默认存储类型还是 object 。
要存储为 string 类型，需要显式的设置 dtype 参数
或者在创建 Series 或 DataFrame 之后，使用 astype 转换类型
也可以使用 StringDtype/"string" 转换其他非字符串类型的数据
转换现有数据的类型
StringDtype 类型对象与 object 类型之间存在一些差异
两个结果的输出都是 Int64 类型。将其与 object 类型比较
当存在 NA 值时，输出为 float64 。类似地，对于返回布尔值的方法
Series 和 Index 有一套字符串处理方法，可以方便地对数组的每个元素进行操作，最重要的是，这些方法会自动忽略缺失值。
这些方法可以通过 str 属性访问，通常具有与内置字符串方法相匹配的名称
Index 上的字符串方法对于清理或转换 DataFrame 的列特别有用。
例如，您可能有带有前导或后置空格的列
因为 df.columns 是一个 Index 对象，所以我们可以使用 .str 访问器
我们可以根据需要对列名进行处理，然后重新设置列名。
例如，我们删除列名的前后空格，并将其改为小写字母，同时用 _ 替换剩余的空格
split 方法会返回一个值为 list 的 Series
可以使用 get 或 [] 访问拆分后的列表中的元素
更简单的方法是设置 expand 参数，返回一个 DataFrame
当原来的 Series 包含 StringDtype 类型的数据时，输出列也将全部为 StringDtype
当然，也可以设置切割次数
它还有个对应的 rsplit 方法，从右边起始对字符串进行拆分
replace 参数支持使用正则表达式，前两个参数是 pat (匹配模式) 和 repl (替换字符串)
如果只是想要替换字符串字面值，可以将 regex 参数设置为 False ，而不需要对每个特殊字符进行转义。此时 pat 和 repl 参数必须是字符串
此外， replace 方法还接受一个可调用的替换函数，会使用 re.sub() 方法在每个匹配的模式上调用该函数
该函数需要传入一个正则对象作为位置参数，并返回一个字符串。例如
replace 方法的 pat 参数还接受 re.compile() 编译的正则表达式对象。所有的 flags 需要在编译正则对象时设置
如果在 replace 中设置 flags 参数，则会抛出异常
有几种方法可以将一个 Series 或 Index 与自己或其他的 Series 或 Index 相连接，所有这些方法都是基于 cat() 方法
可以连接一个 Series 或 Index 的内容
如果未指定 sep 参数，则默认为空字符串
默认会跳过缺失值，也可以使用 na_rep 指定缺失值的表示方式
cat() 的第一个参数 others 可以是类似列表的对象，但是其长度需要和调用对象一致
只要两个对象中存在缺失值，对应的结果中也是缺失值，除非指定了 na_rep
others 参数也可以是二维的，但是得保证其行数必须与调用的对象一致
对于 Series 或 DataFrame 的连接，可以通过设置 join 参数指定对齐方式
通常 join 可选范围为： 'left' , 'outer' , 'inner' , 'right' 。此时，不再要求两个对象长度一致
当 others 参数是 DataFrame 时，也可以使用
可以将一些类似数组的对象（如 Series ， Index 等）放在一个类似列表的容器中，然后传递给 cat
对于没有索引的对象，其长度必须与调用 cat 的对象相同。但是 Series 和 Index 可以是任意的，除非设置了 json=None 。
如果在 others 参数上包含不同索引的对象，且设置了 join='right' ，则最后的结果将会是这些索引的并集
Python常用的正则表达式处理函数详解
正则表达式是一个特殊的字符序列，用于简洁表达一组字符串特征，检查一个字符串是否与某种模式匹配，使用起来十分方便。
在Python中，我们通过调用re库来使用re模块：
import re
下面介绍Python常用的正则表达式处理函数。
re.match函数
re.match 函数从字符串的起始位置匹配正则表达式，返回match对象，如果不是起始位置匹配成功的话，match()就返回None。
re.match(pattern, string, flags=0)
pattern：匹配的正则表达式。
string：待匹配的字符串。
flags：标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。具体参数为：
re.I：忽略大小写。
re.L：表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境。
re.M：多行模式。
re.S：即 . ，并且包括换行符在内的任意字符（. 不包括换行符）。
re.U：表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库。
re.X：为了增加可读性，忽略空格和 # 后面的注释。
import re #从起始位置匹配 r1=re.match('abc','abcdefghi') print(r1) #不从起始位置匹配 r2=re.match('def','abcdefghi') print(r2)
运行结果：
其中，span表示匹配成功的整个子串的索引。
使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。
group(num)：匹配的整个表达式的字符串，group() 可以一次输入多个组号，这时它将返回一个包含那些组所对应值的元组。
groups()：返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。
import re s='This is a demo' r1=re.match(r'(.*) is (.*)',s) r2=re.match(r'(.*) is (.*?)',s) print(r1.group()) print(r1.group(1)) print(r1.group(2)) print(r1.groups()) print() print(r2.group()) print(r2.group(1)) print(r2.group(2)) print(r2.groups())
运行结果：
上述代码中的(.*)和(.*?)表示正则表达式的贪婪匹配与非贪婪匹配。
re.search函数
re.search函数扫描整个字符串并返回第一个成功的匹配，如果匹配成功则返回match对象，否则返回None。
re.search(pattern, string, flags=0)
pattern：匹配的正则表达式。
string：待匹配的字符串。
flags：标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。
import re #从起始位置匹配 r1=re.search('abc','abcdefghi') print(r1) #不从起始位置匹配 r2=re.search('def','abcdefghi') print(r2)
运行结果：
使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。
group(num=0)：匹配的整个表达式的字符串，group() 可以一次输入多个组号，这时它将返回一个包含那些组所对应值的元组。
groups()：返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。
import re s='This is a demo' r1=re.search(r'(.*) is (.*)',s) r2=re.search(r'(.*) is (.*?)',s) print(r1.group()) print(r1.group(1)) print(r1.group(2)) print(r1.groups()) print() print(r2.group()) print(r2.group(1)) print(r2.group(2)) print(r2.groups())
运行结果：
从上面不难发现re.match与re.search的区别：re.match只匹配字符串的起始位置，只要起始位置不符合正则表达式就匹配失败，而re.search是匹配整个字符串，直到找到一个匹配为止。
re.compile 函数
compile 函数用于编译正则表达式，生成一个正则表达式对象，供 match() 和 search() 这两个函数使用。
re.compile(pattern[, flags])
pattern：一个字符串形式的正则表达式。
flags：可选，表示匹配模式，比如忽略大小写，多行模式等。
import re #匹配数字 r=re.compile(r'\d+') r1=r.match('This is a demo') r2=r.match('This is 111 and That is 222',0,27) r3=r.match('This is 111 and That is 222',8,27) print(r1) print(r2) print(r3)
运行结果：
findall函数
搜索字符串，以列表形式返回正则表达式匹配的所有子串，如果没有找到匹配的，则返回空列表。
需要注意的是，match 和 search 是匹配一次，而findall 匹配所有。
findall(string[, pos[, endpos]])
string：待匹配的字符串。
pos：可选参数，指定字符串的起始位置，默认为0。
endpos：可选参数，指定字符串的结束位置，默认为字符串的长度。
import re #匹配数字 r=re.compile(r'\d+') r1=r.findall('This is a demo') r2=r.findall('This is 111 and That is 222',0,11) r3=r.findall('This is 111 and That is 222',0,27) print(r1) print(r2) print(r3)
运行结果：
re.finditer函数
和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。
re.finditer(pattern, string, flags=0)
pattern：匹配的正则表达式。
string：待匹配的字符串。
flags：标志位，用于控制正则表达式的匹配方式，如是否区分大小写，多行匹配等。
import re r=re.finditer(r'\d+','This is 111 and That is 222') for i in r: print (i.group())
运行结果：
re.split函数
将一个字符串按照正则表达式匹配的子串进行分割后，以列表形式返回。
re.split(pattern, string[, maxsplit=0, flags=0])
pattern：匹配的正则表达式。
string：待匹配的字符串。
maxsplit：分割次数，maxsplit=1分割一次，默认为0，不限次数。
flags：标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等。
import re r1=re.split('\W+','This is 111 and That is 222') r2=re.split('\W+','This is 111 and That is 222',maxsplit=1) r3=re.split('\d+','This is 111 and That is 222') r4=re.split('\d+','This is 111 and That is 222',maxsplit=1) print(r1) print(r2) print(r3) print(r4)
运行结果：
re.sub函数
re.sub函数用于替换字符串中的匹配项。
re.sub(pattern, repl, string, count=0, flags=0)
pattern：正则中的模式字符串。
repl：替换的字符串，也可为一个函数。
string：要被查找替换的原始字符串。
count：模式匹配后替换的最大次数，默认0表示替换所有的匹配。
import re r='This is 111 and That is 222' # 删除字符串中的数字 r1=re.sub(r'\d+','',r) print(r1) # 删除非数字的字符串 r2=re.sub(r'\D','',r) print(r2)
运行结果：
到此这篇关于Python常用的正则表达式处理函数详解的文章就介绍到这了，希望大家以后多多支持！
Python处理字符串必备方法
字符串是Python中基本的数据类型，几乎在每个Python程序中都会使用到它。
▍1、Slicing
slicing切片，按照一定条件从列表或者元组中取出部分元素（比如特定范围、索引、分割值）
▍2、****strip()
strip()方法用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。
在使用strip()方法时，默认去除空格或换行符，所以#号并没有去除。
可以给strip()方法添加指定字符，如下所示。
此外当指定内容不在头尾处时，并不会被去除。
第一个\n前有个空格，所以只会去取尾部的换行符。
最后strip()方法的参数是剥离其值的所有组合，这个可以看下面这个案例。
最外层的首字符和尾字符参数值将从字符串中剥离。字符从前端移除，直到到达一个不包含在字符集中的字符串字符为止。
在尾部也会发生类似的动作。
▍3、****lstrip()
移除字符串左侧指定的字符（默认为空格或换行符）或字符序列。
同样的，可以移除左侧所有包含在字符集中的字符串。
▍4、rstrip()
移除字符串右侧指定的字符（默认为空格或换行符）或字符序列。
▍5、****removeprefix()
Python3.9中移除前缀的函数。
和strip()相比，并不会把字符集中的字符串进行逐个匹配。
▍6、removesuffix()
Python3.9中移除后缀的函数。
▍7、****replace()
把字符串中的内容替换成指定的内容。
▍8、****re.sub()
re是正则的表达式，sub是substitute表示替换。
re.sub则是相对复杂点的替换。
和replace()做对比，使用re.sub()进行替换操作，确实更高级点。
▍9、****split()
对字符串做分隔处理，最终的结果是一个列表。
当不指定分隔符时，默认按空格分隔。
此外，还可以指定字符串的分隔次数。
▍10、****rsplit()
从右侧开始对字符串进行分隔。
▍11、****join()
string.join(seq)。以string作为分隔符，将seq中所有的元素(的字符串表示)合并为一个新的字符串。
▍12、****upper()
将字符串中的字母，全部转换为大写。
▍13、****lower()
将字符串中的字母，全部转换为小写。
▍14、capitalize()
将字符串中的首个字母转换为大写。
▍15、****islower()
判断字符串中的所有字母是否都为小写，是则返回True，否则返回False。
▍16、isupper()
判断字符串中的所有字母是否都为大写，是则返回True，否则返回False。
▍17、****isalpha()
如果字符串至少有一个字符并且所有字符都是字母，则返回 True，否则返回 False。
▍18、isnumeric()
如果字符串中只包含数字字符，则返回 True，否则返回 False。
▍19、isalnum()
如果字符串中至少有一个字符并且所有字符都是字母或数字，则返回True，否则返回 False。
▍20、count()
返回指定内容在字符串中出现的次数。
▍21、****find()
检测指定内容是否包含在字符串中，如果是返回开始的索引值，否则返回-1。
此外，还可以指定开始的范围。
▍22、rfind()
类似于find()函数，返回字符串最后一次出现的位置，如果没有匹配项则返回 -1。
▍23、startswith()
检查字符串是否是以指定内容开头，是则返回 True，否则返回 False。
**
**
▍24、****endswith()
检查字符串是否是以指定内容结束，是则返回 True，否则返回 False。
▍25、****partition()
string.partition(str)，有点像find()和split()的结合体。
从str出现的第一个位置起,把字符串string分成一个3 元素的元组(string_pre_str,str,string_post_str)，如果string中不包含str则 string_pre_str==string。
▍26、center()
返回一个原字符串居中，并使用空格填充至长度width的新字符串。
▍27、ljust()
返回一个原字符串左对齐，并使用空格填充至长度width的新字符串。
▍28、rjust()
返回一个原字符串右对齐，并使用空格填充至长度width的新字符串。
▍29、f-Strings
f-string是格式化字符串的新语法。
与其他格式化方式相比，它们不仅更易读，更简洁，不易出错，而且速度更快！
▍30、swapcase()
翻转字符串中的字母大小写。
▍31、zfill()
string.zfill(width)。
返回长度为width的字符串，原字符串string右对齐，前面填充0。
参考文献：
新闻名称：python文字处理函数 python写文字方法
文章网址：http://scgulin.cn/article/hjeigg.html
