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://myzitong.com/article/hjeigg.html