python 内置函数 std python内置函数str

• str.capitalize()

格式：

capitalize(...)
    S.capitalize() -> str
    
   返回S的大写版本，即生成第一个字符有大写字母其余小写字母。

   返回值为str类型的结果。

String = 'My Name Is Tom'
result = String.capitalize()
print(result)

 输出结果：

My name is tom

•  str.casefold()

格式：

casefold(...)
    S.casefold() -> str
    
    返回S的小写版本，即生成所有字符都是小写，如果非中文和英文的字符也将变成小写，如：德语的Ö将会变成q。

    返回值为str类型的结果。

String = 'AÄBCDEFGHIJKLMNOÖPQRSßTUÜVWXYZ'
result = String.casefold()
print(result)

输出结果：

aäbcdefghijklmnoöpqrsßtuüvwxyz

• str.center()

格式：

center(...)
    S.center(width[, fillchar]) -> str
    

    width=字符串占用宽度

    fillchar=填充字符（默认为空格填充）

    返回以S字符串的长度为中心的宽度。其余位置使用指定的字符完成填充。

    返回值为str类型的结果。

String = 'Hello'
result = String.center(10,'#')
print(result)

输出结果：

##Hello###

• str.count()

格式：

count(...)
    S.count(sub[, start[, end]]) -> int
    

    sub=查找字符串

    start=起始位置

    stop=结束位置

    返回sub字符在start到stop位置的值重复几次，如果有一个参数，那么start和stop默认为0和S最大长度，如果有两个参数，那么stop默认为S最大长度。

    返回值为int类型的结果。

String = 'Hello World'
result1 = String.count('l')
result2 = String.count('l',8)
result3 = String.count('l',3,len(String))
print(result1)
print(result2)
print(result3)

输出结果：

3

1

2

• str.encode()

格式：

encode(...)
    S.encode(encoding='utf-8', errors='strict') -> bytes
    
    使用编码的编码解码器对S进行编码。缺省编码“UTF-8”是“UTF-8”。可以设置错误来设置不同的错误。处理方案。默认为“严格”，意味着编码错误增加。一个UnoDeEnoCo错误。其他可能的值是“忽略”、“替换”和“XML字符检索”以及其他注册的其他名称可以处理UndoDeNoCoDebug的RealStaysRebug。

    返回值为byte类型的结果。

String = 'Hello World'
result = String.encode('UTF-8')
print(result)

 返回结果：

b'Hello World'

• str.endswith()

格式：

endswith(...)
    S.endswith(suffix[, start[, end]]) -> bool
    

    suffix=结尾字符串

    start=起始位置

    stop=结束位置

    如果S以指定的后缀结束，则返回true，否则为false。有可选的启动，测试S从那个位置开始。+具有可选的结束，停止在该位置比较S。后缀也可以是一组字符串来尝试。如果有一个参数，start和stop为0和S最大长度，如果有两个参数，stop为S最大长度。

    返回值为bool类型的结果。

String = '[e-mail]'
result1 = String.endswith('.com')
result2 = String.endswith('.com',8)
result3 = String.endswith('.com',0,8)
print(result1)
print(result2)
print(result3)

输出结果：

True
True
False

• str.expandtabs()

格式：

expandtabs(...)
    S.expandtabs(tabsize=8) -> str
    

    tabsize=制表符占用宽度（默认为8）
    返回一个S的副本，其中所有的制表符都是使用空格展开的。如果没有给定Tabsize，则默认有8个字符的制表符大小。

    返回值为str类型的结果。

String = '\t\t\t\t'
result = String.expandtabs(4)
print(String)
print(result)

输出结果：

(                                )三十二个空格

(                )十六个空格，本来一个制表符的默认宽度为8，现在为4。

• str.find()

格式：

find(...)
    S.find(sub[, start[, end]]) -> int
    

    sub=查找字符串

    start=起始位置

    end=结束位置

    返回sub字符串在start位置到end位置中S的下标索引，会从左边进行搜索，若不存在则返回-1。如果有一个参数，start和end的默认参数为0和S的最大长度，如果有两个参数，end为S的最大长度。

    返回值为int类型的结果。

String = 'Hello World'
result1 = String.find('l')
result2 = String.find('l',4)
result3 = String.find('o',5,len(String))
print(result1)
print(result2)
print(result3)

输出结果：
2
9
7

• str.format()

格式：

format(...)
    S.format(*args, **kwargs) -> str
    

    *args=元组形式的多参数

    **kwargs=字典形式的多参数

    返回一个格式化版本的S，使用替换从ARGS和KWAGS中取值给用括号（‘{‘and’}’）来标识的地方。

    返回值为str类型的结果。

dict1 = {'name':'Cidy','age':26}
result1 = '{0} {1}'.format('Hello','World')
result2 = 'name={name},age={age}'.format(name='Tom',age=24)
result3 = 'name={name},age={age}'.format(**dict1)
print(result1)
print(result2)
print(result3)

输出结果：

Hello World
name=Tom,age=24
name=Cidy,age=26

• str.format_map()

格式：

format_map(...)
    S.format_map(mapping) -> str
    

    mapping=映射类型的数据（dict）

    使用映射替换来返回S的格式化版本。这些替换用括号（'{'and‘}’）来识别。

    返回值为str类型的结果。

dict1 = {'name':'Cindy','age':25,'sex':'Boy'}
result = 'name={name},age={age},sex={sex}'.format_map(dict1)
print(result)

输出结果：

name=Cindy,age=25,sex=Boy

• str.index()

格式：

index(...)
    S.index(sub[, start[, end]]) -> int
    

    sub=查找字符串

    start=起始位置

    end=结束位置

    返回从start到end位置中查找sub是否在S中，会从左边开始搜索，如果存在返回下标索引，如果不存在则报错ValueError，如果有一个参数，那么start和end为0和S最大长度，如果有两个参数，那么end为S最大长度。

    返回值为int类型的结果

String1 = 'Hello World'
result1 = String1.index('l')
result2 = String1.index('l',3)
result3 = String1.index('l',4)
print(result1)
print(result2)
print(result3)

输出结果：

2
3
9

• str.isalnum()

格式：

isalnum(...)
    S.isalnum() -> bool
    
    如果S中的所有字符都是数字，则返回true或在S中至少有一个字符为数字，否则返回False。这是唯一一个支持所有的数字的函数。

    数字可以是Unicode数字、byte数字、全角数字、罗马数字、汉字数字。

    返回值为bool类型的结果

String1 = '123'#Unicode数字
String2 = b'123'#byte数字
String3 = '１２３'#全角数字
String4 = 'IVVIVII'#罗马数字
String5 = '一二三'#汉字数字
result1 = String1.isalnum()
result2 = String2.isalnum()
result3 = String3.isalnum()
result4 = String4.isalnum()
result5 = String5.isalnum()
print(result1)
print(result2)
print(result3)
print(result4)
print(result5)

输出结果：

True
True
True
True
True

• str.isalpha()

格式：

isalpha(...)
    S.isalpha() -> bool
    
    如果S中的所有字符都是字母，则返回True，否则返回False。

    返回值为bool类型的结果。

String1 = 'abc'
String2 = 'abcde1'
result1 = String1.isalpha()
result2 = String2.isalpha()
print(result1)
print(result2)

输出结果：

True
False

• str.isdecimal()

格式：

isdecimal(...)
    S.isdecimal() -> bool
    
    如果S中的所有字符都是数字，则返回True，否则返回False。

    数字可以是Unicode数字和全角数字。

    数字不可以是罗马数字和汉字数字。

    如果数字为byte数字则会报错，因为byte没有isdecimal这个函数。

    返回值为bool类型的结果。

String1 = '123'#Unicode数字
String2 = b'123'#byte数字
String3 = '１２３'#全角数字
String4 = 'IVVIVII'#罗马数字
String5 = '一二三'#汉字数字
result1 = String1.isdecimal()
result2 = String2.isdecimal()
result3 = String3.isdecimal()
result4 = String4.isdecimal()
result5 = String5.isdecimal()
print(result1)
print(result2)
print(result3)
print(result4)
print(result5)

输出结果：

True
报错
True
False
False

• str.isdigit()

格式：

isdigit(...)
    S.isdigit() -> bool
    
    如果S中的所有字符都是数字，则返回True，否则返回False。

    数字可以是Unicode数字、byte数字、全角数字。

    数字不可以是罗马数字、汉字数字。

    返回值为bool类型的结果。

String1 = '123'#Unicode数字
String2 = b'123'#byte数字
String3 = '１２３'#全角数字
String4 = 'IVVIVII'#罗马数字
String5 = '一二三'#汉字数字
result1 = String1.isdigit()
result2 = String2.isdigit()
result3 = String3.isdigit()
result4 = String4.isdigit()
result5 = String5.isdigit()
print(result1)
print(result2)
print(result3)
print(result4)
print(result5)

输出结果：

True
True
True
False
False

• str.isidentifier()

格式：

isidentifier(...)
    S.isidentifier() -> bool
    
    如果S是有效标识符，则返回true，这是对语言的定义。有效标识符就是正确的变量名。

    使用关键字keyword.iskeyword()来测试保留标识符,keyword需要导入，import keyword。
    例如“def”和“class”。

    返回值为bool类型的结果。

String1 = 'abc'
String2 = 'abc1'
String3 = 'abc_1'
String4 = '_abc1'
String5 = '1_abc'
result1 = String1.isidentifier()
result2 = String2.isidentifier()
result3 = String3.isidentifier()
result4 = String4.isidentifier()
result5 = String5.isidentifier()
print(result1)
print(result2)
print(result3)
print(result4)
print(result5)

输出结果：

True
True
True
True
False

• str.islower()

格式：

islower(...)
    S.islower() -> bool
    
    如果S中不包含大写的情况下，所有字符或一个字符都是小写的，则返回True，否则返回False。

    返回值为bool类型的结果。

String1 = 'hello 123'
String2 = 'hello 世界'
String3 = 'hello abc'
String4 = 'hello _123'
String5 = 'hello ABC'
result1 = String1.islower()
result2 = String2.islower()
result3 = String3.islower()
result4 = String4.islower()
result5 = String5.islower()
print(result1)
print(result2)
print(result3)
print(result4)
print(result5)

输出结果：

True
True
True
True
False

• str.isnumeric()

格式：

isnumeric(...)
    S.isnumeric() -> bool
    

    如果S中的所有字符都是数字，则返回True，否则返回False。

    数字可以是Unicode数字、全角数字、汉子数字。

    数字不可以是罗马数字。

    如果数字为byte数字则会报错，因为byte没有isnumeric这个函数。

    返回值为bool类型的结果。

String1 = '123'#Unicode数字
String2 = b'123'#byte数字
String3 = '１２３'#全角数字
String4 = 'IV'#罗马数字
String5 = '一二三'#汉字数字
result1 = String1.isnumeric()
result2 = String2.isnumeric()
result3 = String3.isnumeric()
result4 = String4.isnumeric()
result5 = String5.isnumeric()
print(result1)
print(result2)
print(result3)
print(result4)
print(result5)

输出结果：

True
报错
True
False
True

• str.printable()

格式：

isprintable(...)
    S.isprintable() -> bool
    
    如果S中的字符是一个可输出的repr()字符串，则返回True，负责返回False。

    返回值为bool类型的结果。

String1 = 'hello world'
String2 = repr('hello world')
String3 = r'hello world'
String4 = 'hello\nworld'
result1 = String1.isprintable()
result2 = String2.isprintable()
result3 = String3.isprintable()
result4 = String4.isprintable()
print(result1)
print(result2)
print(result3)
print(result4)

输出结果：

True
True
True
False

• str.isspace()

格式：

isspace(...)
    S.isspace() -> bool
    
    如果S中的所有字符都是空白，则返回true，在S中至少有一个字符不为空格，则为false。

    返回值为bool类型的结果。

String1 = 'hello world'
String2 = '     '
String3 = 'helloworld'
result1 = String1.isspace()
result2 = String2.isspace()
result3 = String3.isspace()
print(result1)
print(result2)
print(result3)

输出结果：

False
True
False

• str.istitle()

格式：

istitle(...)
    S.istitle() -> bool
    
    如果S是一个被标记的字符串并且至少有一个不为小写，则返回True。如果有一个或多个单词的首字母是小写则返回False。

    返回值为bool类型的结果

String1 = 'Hello World'
String2 = 'Hello world'
String3 = 'hello world'
result1 = String1.istitle()
result2 = String2.istitle()
result3 = String3.istitle()
print(result1)
print(result2)
print(result3)

输出结果：

True
False
False

• str.isupper()

格式：

isupper(...)
    S.isupper() -> bool
    
    如果S中的所有字符都大写，则返回True。至少在S中有一个字符不为大写，就返回False。

    返回值为bool类型的结果。

String1 = 'Hello World'
String2 = 'HELLO WORLD'
result1 = String1.isupper()
result2 = String2.isupper()
print(result1)
print(result2)

输出结果：

 False
True

• str.join()

格式：

join(...)
    S.join(iterable) -> str
    

    iterable=可迭代序列
    返回一个字符串，该字符串是字符串中的字符串的连接。可迭代。元素之间的分隔符是S。

    返回值为str类型的结果。

list1 = ['1','2','3','4','5']
list2 = ['192','168','1','1']
String1 = ','
String2 = '.'
result1 = String1.join(list1)
result2 = String2.join(list2)
print(result1)
print(result2)

输出结果：

1,2,3,4,5
192.168.1.1 

• str.ljust()

格式：

ljust(...)
    S.ljust(width[, fillchar]) -> str
    

    width=字符串占用宽度

    fillchar=填充字符串
    在长度为width的Unicode字符串中返回左对齐形式。填充是使用指定的填充字符fillchar（默认为空格）。

    返回值为str类型的结果。

String1 = '123456789'
String2 = '23456789'
result1 = String1.ljust(10,'0')
result2 = String2.ljust(10,'0')
print(result1)
print(result2)

输出结果：

1234567890
2345678900

• str.lower()

格式：

lower(...)
    S.lower() -> str
    
    返回一个转换为小写的字符串S的副本。

    返回值为str类型的结果。

String1 = 'Hello World'
String2 = 'HELLO WORLD'
result1 = String1.lower()
result2 = String2.lower()
print(result1)
print(result2)

输出结果：

hello world
hello world 

• str.lstrip()

格式：

lstrip(...)
    S.lstrip([chars]) -> str
    

    chars=删除字符
    返回一个删除左边的chars字符的副本，会将左边的chars字符删除掉，当左边的字符不为chars时，会停止删除。（默认为空格）

    返回值为str类型的结果。

String1 = 'hello world'
String2 = 'lower upper'
result1 = String1.lstrip('l')
result2 = String2.lstrip('l')
print(result1)
print(result2)

输出结果：

hello world
ower upper 

• str.maketrans()

格式：

maketrans(x,y,z)

 

    x=需要转换的字符组成的字符串

    y=转换的目标字符组成的字符串

    z=可选参数，表示要删除的字符组成的字符串

    返回一个可用于str.translate()的转换表。如果只有一个参数，它必须是映射Unicode的字典。
枚举（整数）或字符到Unicode序数、字符串或无。将字符键转换成序数。如果有两个参数，它们必须是等长的字符串，
在生成的字典中，X中的每个字符将被映射到在y中的同一位置上的字符。如果有第三个参数，则必须是一个字符串，其字符将被映射到结果中的任意一个。

intab = "helow"
outtab = '12345'
deltab = "thw"
table1 = str.maketrans(intab, outtab)
table2 = str.maketrans(intab, outtab, deltab)
test = "hello world hello world"
print(test.translate(table1))
print(test.translate(table2))

输出结果：

12334 54r3d 12334 54r3d
2334 4r3d 2334 4r3d

• str.partition()

格式：

partition(...)
    S.partition(sep) -> (head, sep, tail)
    

    sep=分割符
    搜索S中的SEP，并返回它之前的部分，会进行左对齐，分离器本身及其后的部分。如果分离器不是找到，返回S和两个空字符串。

    返回值为元组类型的结果。

String1 = 'hello world'
String2 = 'helloworld'
result1 = String1.partition(' ')
result2 = String2.partition(' ')
print(result1)
print(result2)

输出结果：

('hello', ' ', 'world')
('helloworld', '', '') 

• str.replace()

格式：

replace(...)
    S.replace(old, new[, count]) -> str
    

    old=旧字符串

    new=新字符串

    count=替换次数
    返回具有所有子串出现的S的副本旧的被新的取代。如果可选参数计数为给定的，只有第一计数发生被替换。

    返回值为str类型的结果。

String1 = 'Hello world'
String2 = 'hello World'
result1 = String1.replace('H','h')
result2 = String2.replace('h','H')
print(result1)
print(result2)

输出结果：

hello world
Hello World 

• str.rfind()

格式：

rfind(...)
    S.rfind(sub[, start[, end]]) -> int
    

    sub=查找字符串

    start=起始位置

    end=结束位置

    返回sub字符串在start位置到end位置中S的下标索引，会从右边进行搜索，若不存在则返回-1。如果有一个参数，start和end的默认参数为0和S的最大长度，如果有两个参数，end为S的最大长度。

    返回值为int类型的结果。

String = 'Hello World'
result1 = String.rfind('l')
result2 = String.rfind('l',4)
result3 = String.rfind('o',5,len(String))
print(result1)
print(result2)
print(result3)

输出结果：

9
9
7 

• str.rindex()

格式：

rindex(...)
    S.rindex(sub[, start[, end]]) -> int
    

    sub=查找字符串

    start=起始位置

    end=结束位置

    返回从start到end位置中查找sub是否在S中，会从右边开始搜索，如果存在返回下标索引，如果不存在则报错ValueError，如果有一个参数，那么start和end为0和S最大长度，如果有两个参数，那么end为S最大长度。

    返回值为int类型的结果

String1 = 'Hello World'
result1 = String1.rindex('l')
result2 = String1.rindex('l',3)
result3 = String1.rindex('l',4)
print(result1)
print(result2)
print(result3)

输出结果：

9
9
9 

• str.rjust()

格式：

rjust(...)
    S.rjust(width[, fillchar]) -> str
    

    width=字符串占用宽度

    fillchar=填充字符串
    在长度为width的Unicode字符串中返回右对齐形式。填充是使用指定的填充字符fillchar（默认为空格）。

    返回值为str类型的结果。

String1 = '123456789'
String2 = '23456789'
result1 = String1.rjust(10,'0')
result2 = String2.rjust(10,'0')
print(result1)
print(result2)

输出结果：

0123456789
0023456789 

• str.rpartition()

格式：

rpartition(...)
    S.rpartition(sep) -> (head, sep, tail)
    

    sep=分割符
    搜索S中的SEP，并返回它之前的部分，会进行右对齐，分离器本身及其后的部分。如果分离器不是找到，返回S和两个空字符串。

    返回值为元组类型的结果。

String1 = 'hello world'
String2 = 'helloworld'
result1 = String1.rpartition(' ')
result2 = String2.rpartition(' ')
print(result1)
print(result2)

输出结果：

('hello', ' ', 'world')
('', '', 'helloworld') 

• str.rsplit()

格式：

rsplit(...)
    S.rsplit(sep=None, maxsplit=-1) -> list of strings

 

    sep=分割字符串

    maxsplit=最大分割次数
    返回SEP中的单词列表，使用SEP作为分隔符字符串，从字符串的结尾开始，我在前面工作。如果给出最大分割，则最大分割进行劈裂。如果未指定SEP，则任何空白空间字符串是分离器。

    返回值为list类型的结果。

String1 = '192.168.1.1'
String2 = '192,168,1,1'
result1 = String1.rsplit('.')
result2 = String2.rsplit(',')
print(result1)
print(result2)

输出结果：

['192', '168', '1', '1']
['192', '168', '1', '1'] 

• str.rstrip()

格式：

rstrip(...)
    S.rstrip([chars]) -> str
    

    chars=删除字符
    返回一个删除右边的chars字符的副本，会将左边的chars字符删除掉，当左边的字符不为chars时，会停止删除。（默认为空格）

    返回值为str类型的结果。

String1 = 'hello world'
String2 = 'lower upper'
result1 = String1.rstrip('l')
result2 = String2.rstrip('l')
print(result1)
print(result2)

输出结果：

hello world
lower upper 

• str.split()

格式：

split(...)
    S.split(sep=None, maxsplit=-1) -> list of strings
    

    sep=分割字符串

    maxsplit=最大分割次数
    返回SEP中的单词列表，使用SEP作为分隔符字符串，从字符串的开头开始，我在前面工作。如果给出最大分割，则最大分割进行劈裂。如果未指定SEP，则任何空白空间字符串是分离器。

    返回值为list类型的结果。

String1 = '192.168.1.1'
String2 = '192,168,1,1'
result1 = String1.split('.')
result2 = String2.split(',')
print(result1)
print(result2)

输出结果：

['192', '168', '1', '1']
['192', '168', '1', '1'] 

• str.splitlines()

格式：

splitlines(...)
    S.splitlines([keepends]) -> list of strings

 

    keepends=结束符（像制表符和换行这些特殊的来截断）
    返回S中的行的列表，在行边界处断开，以换行、制表符这些特殊的转义字符来截断处理。

    返回值为list类型的结果。

String1 = '192\n168\n1\n1'
String2 = '192,168,1,1'
result1 = String1.splitlines()
result2 = String2.splitlines()
print(result1)
print(result2)

输出结果：

['192', '168', '1', '1']
['192,168,1,1']

• str.startswith()

格式：

startswith(...)
    S.startswith(prefix[, start[, end]]) -> bool
    

    prefix=指定字符串

    start=起始位置

    end=结束位置
    如果S以指定的prefix开头，则返回True，否则为False。有可选的启动，测试S从start位置开始到end位置结束。+具有可选的结束，停止在该位置比较S。前缀也可以是一个字符串的元组来尝试。

    返回值为bool类型的结果。

String1 = '123.com'
String2 = '123456.com'
result1 = String1.startswith('123')
result2 = String2.startswith('123456')
result3 = String2.startswith('123',1)
result4 = String2.startswith('456',3,len(String2))
print(result1)
print(result2)
print(result3)
print(result4)

 输出结果：

True
True
False
True

• str.strip()

格式：

strip(...)
    S.strip([chars]) -> str
    

    [chars]=指定字符串（可用可不用，默认为空格）
    返回带前导和尾随的字符串S的副本删除空白。如果给定字符而不是字符，则用字符替换字符。

    返回值为str类型的结果。

String1 = '  Hello World   '
String2 = '11Hello World111'
String3 = 'aaaHello Worldaaa'
result1 = String1.strip()
result2 = String2.strip('1')
result3 = String3.strip('a')
print(result1)
print(result2)
print(result3)

 输出结果：

Hello World
Hello World
Hello World

• str.swapcase()

格式：

swapcase(...)
    S.swapcase() -> str
    
    返回带有大写字符转换为小写字母的S的拷贝反之亦然。大写转小写，小写转大写。

    返回值为str类型的结果。

String1 = 'hello WORLD'
String2 = 'HELLO world'
String3 = 'hello world'
String4 = 'HELLO WORLD'
result1 = String1.swapcase()
result2 = String2.swapcase()
result3 = String3.swapcase()
result4 = String4.swapcase()
print(result1)
print(result2)
print(result3)
print(result4)

输出结果：

HELLO world
hello WORLD
HELLO WORLD
hello world 

• str.title()

格式：

title(...)
    S.title() -> str
    
    返回一个S字符串的副本，即单词从标题开始,其余性状均为小写。

    返回值为str类型的结果。

String1 = 'Hello world'
String2 = 'hello World'
String3 = 'hello world'
result1 = String1.title()
result2 = String2.title()
result3 = String3.title()
print(result1)
print(result2)
print(result3)

输出结果：

Hello World
Hello World
Hello World

• str.translate()

格式：

translate(...)
    S.translate(table) -> str
    

    table=maketrans生成的转换表
    返回一个字符串S的副本，其中每个字符都已映射，通过给定的转换表。将对应的值进行更改，比如table的映射关系是1转成a，2转成b，3转成c，那么当S的字符串中有123是会被转换为相应的结果。

    返回值为str类型的结果。

a = '123'
b = 'abc'
c = '123'
d = 'hello world 123123'
table = str.maketrans(a,b)
result1 = c.translate(table)
result2 = d.translate(table)
print(result1)
print(result2)

 输出结果：

abc
hello world abcabc

• str.upper()

格式：

upper(...)
    S.upper() -> str
    
    返回S转换为大写的副本。

    返回值为str类型的结果。

String1 = 'hello world'
String2 = 'Hello World'
result1 = String1.upper()
result2 = String2.upper()
print(result1)
print(result2)

输出结果： 

HELLO WORLD
HELLO WORLD

• str.zfill()

格式：

zfill(...)
    S.zfill(width) -> str
    

    width=字符串宽度

    左边用零来填充一个数字字符串s，以填充每一个字段（指定宽度）。字符串S永远不会被截断。

    返回值为str类型的结果。

String1 = 'abc'
String2 = ' abc'
result1 = String1.zfill(10)
result2 = String2.zfill(5)
print(result1)
print(result2)

输出结果：

0000000abc
0 abc