python一个以回车结束的字符串_Python 学习总结——字符串

1 Python 字符串的 CRUD 操作

1.1 创建字符串

字符串是 Python 中最常用的数据类型。我们可以使用引号('或")来创建字符串，或使用三引号来创建字符串文本段落(允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符)。

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

str1 = 'Hello World!'

str2 = "藕丝空间"

str3 = '''

藕丝空间，编程我们是认真的！

你会编程吗？

白日依山尽，

黄河入河流，

欲穷千里目，

更上一层楼。

'''

print(str1, str2)

print(str3)

Hello World! 藕丝空间

藕丝空间，编程我们是认真的！

你会编程吗？

白日依山尽，

黄河入河流，

欲穷千里目，

更上一层楼。

1.2 访问字符串中的值

Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。

Python 访问子字符串，可以使用方括号来截取字符串，如下实例：

str1 = 'Hello World!'

str2 = "藕丝空间"

print(str1, str2)

print('str1[0]: ', str1[0])

print('str1[:-1]: ', str1[:-1])

print('str1[-6:-1]: ', str1[-6:-1])

print('str1[1:6:2]: ', str1[1:6:2])

print('str1[-1:-6:-2]: ', str1[-1:-6:-2])

print('str2[1:3]', str2[1:3])

Hello World! 藕丝空间

str1[0]: H

str1[:-1]: Hello World

str1[-6:-1]: World

str1[1:6:2]: el

str1[-1:-6:-2]: !lo

str2[1:3] 丝空

1.3 字符串更新

可以通过切片截取字符串的一部分并与其他字段拼接，如下实例：

str1 = 'Hello World!'

str2 = "藕丝空间"

print ("已更新字符串 : ", str1[:6] + str2)

已更新字符串 : Hello 藕丝空间

1.4 删除字符串

str1 = 'Hello World!'

str2 = "藕丝空间"

del str1, str2

# print(str1)

print(str2)

---------------------------------------------------------------------------

NameError Traceback (most recent call last)

in ()

4 del str1, str2

5 # print(str1)

----> 6 print(str2)

NameError: name 'str2' is not defined

2 字符串运算符

2.1 +

字符串连接

str1 = 'Hello '

str2 = "藕丝空间"

print(str1+str2)

Hello 藕丝空间

2.2 *

重复输出字符串

str2 = "藕丝空间"

print(str2*2)

print(str2*3)

藕丝空间藕丝空间

藕丝空间藕丝空间藕丝空间

2.3 [ ]

通过索引获取字符串中字符

以字符串 abcdef 为例。分别列出了使用正索引和负索引来定位字符的情况。

[图片上传失败...(image-ab7b9f-1523605502650)]

str1 = 'Hello World!'

str2 = "藕丝空间"

print('str1[0]: ', str1[0])

print('str1[:-1]: ', str1[:-1])

print('str1[-6:-1]: ', str1[-6:-1])

print('str1[1:6:2]: ', str1[1:6:2])

print('str1[-1:-6:-2]: ', str1[-1:-6:-2])

print('str2[1:3]', str2[1:3])

str1[0]: H

str1[:-1]: Hello World

str1[-6:-1]: World

str1[1:6:2]: el

str1[-1:-6:-2]: !lo

str2[1:3] 丝空

2.4 in、not in

in 成员运算符 - 如果字符串中包含给定的字符返回 True。

not in 成员运算符 - 如果字符串中不包含给定的字符返回 True。

str1 = 'Hello World!'

str2 = "藕丝空间"

print('Hello' in str1)

print('Hello' in str2)

print('Hello' not in str1)

print('Hello' not in str2)

True

False

False

True

2.5 r/R

原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r(可以大小写)以外，与普通字符串有着几乎完全相同的语法。

print('\n')

print(r'\n')

print('\t')

print(R'\t')

\n

\t

Python转义字符

在需要在字符中使用特殊字符时，python用反斜杠()转义字符。如下表：

转义字符

描述

(在行尾时)

续行符

\

反斜杠符号

'

单引号

"

双引号

\a

响铃

\b

退格(Backspace)

\e

转义

\000

空

\n

换行

\v

纵向制表符

\t

横向制表符

\r

回车

\f

换页

\oyy

八进制数，yy代表的字符，例如：\o12代表换行

\xyy

十六进制数，yy代表的字符，例如：\x0a代表换行

\other

其它的字符以普通格式输出

3 格式化字符串

3.1 使用字符串格式符 %s

Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。

在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。

3.1.1 使用 %s 或 %r 格式化字符串

%s 字符串 (采用str()的显示)

%r 字符串 (采用repr()的显示)

print("I'm %s. I'm %d year old" % ('Tom', 30))

print("I'm %r. I'm %d year old" % (ord('H'), 30))

print("I'm %s. I'm %d year old" % (chr(ord('H')), 30))

print("repr() 显示引号: %r; str() 不显示: %s" % ('test1', 'test2'))

I'm Tom. I'm 30 year old

I'm 72. I'm 30 year old

I'm H. I'm 30 year old

repr() 显示引号: 'test1'; str() 不显示: test2

3.1.2 使用 %c 格式化单个字符及其ASCII码

print("I'm %c. I'm %d year old" % (ord('H'), 30))

print("I'm %c. I'm %d year old" % (ord('t'), 30))

print("ord('t') 的值是 ", ord('t'))

I'm H. I'm 30 year old

I'm t. I'm 30 year old

ord('t') 的值是 116

3.1.3 其它格式

%b 二进制整数，这种格式不支持使用 % 来格式化字符串

%d 十进制整数

%i 十进制整数

%o 八进制整数

%x 十六进制整数

%e 指数 (基底写为e)

%E 指数 (基底写为E)

%f 浮点数

%F 浮点数，与上相同

%g 指数(e)或浮点数 (根据显示长度)

%G 指数(E)或浮点数 (根据显示长度)

print("I'm %s. I'm %d year old" % ('十进制', 30))

print("I'm %s. I'm %i year old" % ('十进制', 30))

print("I'm %s. I'm %o year old" % ('八进制', 30))

print("I'm %s. I'm %x year old" % ('十六进制', 30))

print("I'm %s. I'm %e year old" % ('指数', 30))

print("I'm %s. I'm %E year old" % ('指数', 30))

print("I'm %s. I'm %f year old" % ('浮点数', 30))

print("I'm %s. I'm %f year old" % ('浮点数', 30))

print("I'm %s. I'm %F year old" % ('浮点数', 30))

print("I'm %s. I'm %g year old" % ('Tom', 30.00000))

print("I'm %s. I'm %G year old" % ('Tom', 30.00000))

print("I'm %s. I'm %g year old" % ('Tom', 3.000000E+01))

print("I'm %s. I'm %G year old" % ('Tom', 3.000000e+01))

I'm 十进制. I'm 30 year old

I'm 十进制. I'm 30 year old

I'm 八进制. I'm 36 year old

I'm 十六进制. I'm 1e year old

I'm 指数. I'm 3.000000e+01 year old

I'm 指数. I'm 3.000000E+01 year old

I'm 浮点数. I'm 30.000000 year old

I'm 浮点数. I'm 30.000000 year old

I'm Tom. I'm 30 year old

I'm Tom. I'm 30 year old

I'm Tom. I'm 30 year old

I'm Tom. I'm 30 year old

3.1.4 更复杂的控制

%[(name)][flags][width].[precision]

(name): 命名,用于字典控制赋值

flags: 可以有+,-。+表示右对齐(默认)。-表示左对齐。' '为一个空格，用来填充字符。0表示使用0填充数字。

width: 显示宽度,总长度,会补齐空格.

precision: 表示小数点后精度.

使用字典来赋值

print("I'm %(name)s. I'm %(age)d year old" % {'name': '十进制', 'age': 30})

I'm 十进制. I'm 30 year old

对齐及填充

print("I'm %6s. I'm %06d year old" % ('整数', 30)) # 字符串默认右对齐，数字显示 6 位，位数不够，用 0 补齐。

print("I'm %-10s. I'm %.10f year old" % ('浮点数', 30))# 字符串左对齐，浮点数显示 10 位小数

print("I'm %-10s. I'm %10.2f year old" % ('浮点数', 30))# 字符串左对齐，浮点数显示 2 位小数，默认右对齐。

print("I'm %-10s. I'm %10.10f year old" % ('浮点数', 30))# 字符串左对齐，浮点数显示 10 位小数，小数点精度可以突破显示宽度限制。

I'm 整数. I'm 000030 year old

I'm 浮点数 . I'm 30.0000000000 year old

I'm 浮点数 . I'm 30.00 year old

I'm 浮点数 . I'm 30.0000000000 year old

3.2 使用格式化字符串的函数 str.format()

Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。

基本语法是通过 {} 和 : 来代替以前的 % 。

3.2.1 按位置访问参数

print('{}, {}, {}'.format('a', 'b', 'c')) # 默认从左到右顺序，按位置赋值，占位符要和元组的长度一致

print('{0}, {1}, {2}'.format('a', 'b', 'c'))

print('{2}, {1}, {0}'.format('a', 'b', 'c'))

print('{2}, {1}, {0}'.format(*'abc') ) # 通过 * 进行解包

print('{0}{1}{0}'.format('藕丝', 'cad')) # 位置参数可重复

a, b, c

a, b, c

c, b, a

c, b, a

藕丝cad藕丝

3.2.2 按名称访问参数

print('坐标: {latitude}, {longitude}'.format(latitude='37.24N', longitude='-115.81W')) # latitude 纬度， longitude 经度

coord = {'latitude': '37.24N', 'longitude': '-115.81W'}

print('坐标: {latitude}, {longitude}'.format(**coord)) # ** 表示是字典变量

坐标: 37.24N, -115.81W

坐标: 37.24N, -115.81W

3.2.3 访问参数的属性

c = 3-5j # Python 中一切皆对象，复数具有“real(实部)”和“imag(虚部)”两个属性。

('The complex number {0} is formed from the real part {0.real} '

'and the imaginary part {0.imag}.').format(c)

'The complex number (3-5j) is formed from the real part 3.0 and the imaginary part -5.0.'

3.2.4 按索引访问参数

coord = (3, 5)

'X: {0[0]}; Y: {0[1]}'.format(coord)

'X: 3; Y: 5'

3.2.5 替代 %s 和 %r

"repr() shows quotes: {!r}; str() doesn't: {!s}".format('test1', 'test2')

"repr() shows quotes: 'test1'; str() doesn't: test2"

3.2.6 对齐文本并指定宽度

'{:<30}'.format('左对齐')

'左对齐 '

'{:>30}'.format('右对齐')

' 右对齐'

'{:^30}'.format('居中')

' 居中 '

'{:*^30}'.format('居中') # 使用 * 填充

'**************居中**************'

3.2.7 替换％+ f，％-f和％f

'{:+f}; {:+f}'.format(3.14, -3.14) # 带符号

'+3.140000; -3.140000'

'{: f}; {: f}'.format(3.14, -3.14) # 不显示正号，但保留一个空格位置

' 3.140000; -3.140000'

'{:-f}; {:-f}'.format(3.14, -3.14) # 与 '{:f}; {:f}' 作用相同

'3.140000; -3.140000'

'{:10f}; {:2f}'.format(3.14, -3.14) # 设置字符串的总宽度，如果当前宽度大于设置的总宽度，则显示当前宽度。

' 3.140000; -3.140000'

'{:10.1f}; {:.3f}'.format(3.14, -3.14) # 设置小数点的宽度

' 3.1; -3.140'

3.2.8 替换％x和％o

"int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}".format(42) # 比使用 % 格式化的方式多了处理二进制的符号

'int: 42; hex: 2a; oct: 52; bin: 101010'

"int: {0:d}; hex: {0:#x}; oct: {0:#o}; bin: {0:#b}".format(42) # 显示十六进制，八进制，二进制的字首

'int: 42; hex: 0x2a; oct: 0o52; bin: 0b101010'

3.2.9 使用逗号作为千位分隔符

'{:,}'.format(1234567890)

'1,234,567,890'

3.2.10 显示百分比

points = 19

total = 22

'Correct answers: {:.2%}'.format(points/total)

'Correct answers: 86.36%'

3.2.11 使用特定类型格式

import datetime

d = datetime.datetime(2018, 7, 4, 12, 15, 58)

'{:%Y-%m-%d %H:%M:%S}'.format(d)

'2018-07-04 12:15:58'

3.2.12 嵌套参数和更复杂的例子

print(list(zip('', ['left', 'center', 'right'])))

for align, text in zip('', ['left', 'center', 'right']):

print('{0:{fill}{align}16}'.format(text, fill=align, align=align)) # {0} 中的 0 可有可无

[('', 'right')]

left<<<<<<<<<<<<

^^^^^center^^^^^

>>>>>>>>>>>right

octets = [192, 168, 0, 1]

'{:02X}{:02X}{:02X}{:02X}'.format(*octets) # 按照十六进制的方式显示。

'C0A80001'

'{:02X}'.format(192)

'C0'

int(_, 16)

192

width = 5

for num in range(5,12):

for base in 'dXob': # 用于显示 5-11 的数字的十进制，十六进制，八进制和二进制。

print('{0:{width}{base}}'.format(num, base=base, width=width), end=' ')

print()

5 5 5 101

6 6 6 110

7 7 7 111

8 8 10 1000

9 9 11 1001

10 A 12 1010

11 B 13 1011

4 字符串模板

class string.Template(template):

'''参数为字符串对象模板'''

substitute(mapping, **kwds):

'''执行模板替换，返回一个新的字符串。映射是类似字典的对象，其键与模板中的占位符相匹配。'''

safe_substitute(mapping, **kwds):

'''与 substitute() 功能类似，但会对占位符中的 $ 进行过滤，显示原始符号。'''

from string import Template

s = Template('$who likes $what')

s.substitute(who='Tom', what='jerry')

'Tom likes jerry'

d = dict(who='Tom')

print(d)

Template('Give $who $100').substitute(d) # 字符串模板中带有无效的 $ 占位符

{'who': 'Tom'}

---------------------------------------------------------------------------

ValueError Traceback (most recent call last)

in ()

1 d = dict(who='Tom')

2 print(d)

----> 3 Template('Give $who $100').substitute(d)

/usr/lib/python3.6/string.py in substitute(*args, **kws)

124 raise ValueError('Unrecognized named group in pattern',

125 self.pattern)

--> 126 return self.pattern.sub(convert, self.template)

127

128 def safe_substitute(*args, **kws):

/usr/lib/python3.6/string.py in convert(mo)

121 return self.delimiter

122 if mo.group('invalid') is not None:

--> 123 self._invalid(mo)

124 raise ValueError('Unrecognized named group in pattern',

125 self.pattern)

/usr/lib/python3.6/string.py in _invalid(self, mo)

97 lineno = len(lines)

98 raise ValueError('Invalid placeholder in string: line %d, col %d' %

---> 99 (lineno, colno))

100

101 def substitute(*args, **kws):

ValueError: Invalid placeholder in string: line 1, col 11

Template('$who likes $what').substitute(d) # 缺少 key 键值 what。

---------------------------------------------------------------------------

KeyError Traceback (most recent call last)

in ()

----> 1 Template('$who likes $what').substitute(d)

/usr/lib/python3.6/string.py in substitute(*args, **kws)

124 raise ValueError('Unrecognized named group in pattern',

125 self.pattern)

--> 126 return self.pattern.sub(convert, self.template)

127

128 def safe_substitute(*args, **kws):

/usr/lib/python3.6/string.py in convert(mo)

117 named = mo.group('named') or mo.group('braced')

118 if named is not None:

--> 119 return str(mapping[named])

120 if mo.group('escaped') is not None:

121 return self.delimiter

KeyError: 'what'

Template('$who likes $what').safe_substitute(d)

'Tom likes $what'

Template('Give $who $100').safe_substitute(d)

'Give Tom $100'

5 字符串函数

5.1 capitalize()

参数

无。

返回值

该方法返回一个首字母大写的字符串。

str1 = "this is string example from http://www.os373.cn ......wow!!!" # 请避免使用关键字 str 做变量名

print ("str.capitalize() : ", str1.capitalize())

str2 = "藕丝空间"

print ("str.capitalize() : ", str2.capitalize()) # 针对英文书写格式。

str.capitalize() : This is string example from http://www.os373.cn ......wow!!!

str.capitalize() : 藕丝空间

5.2 count(str, beg= 0,end=len(string))

参数

sub -- 搜索的子字符串

start -- 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。

end -- 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。

返回值

该方法返回子字符串在字符串中出现的次数。

str1="http://www.os373.cn"

sub='o'

print ("str.count('o') : ", str1.count(sub))

sub='os'

print ("str.count('run', 0, 10) : ", str1.count(sub,0,10))

str.count('o') : 1

str.count('run', 0, 10) : 0

5.3 encode(encoding="utf-8", errors="strict")

参数

encoding -- 要使用的编码，如: UTF-8。

errors -- 设置不同错误的处理方案。默认为 'strict',意为编码错误引起一个UnicodeError。 其他可能得值有 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及通过 codecs.register_error() 注册的任何值。

返回值

该方法返回编码后的字符串，它是一个 bytes 对象。

str1 = "藕丝空间";

str_utf8 = str1.encode("UTF-8")

str_gbk = str1.encode("GBK")

print(str1)

print("UTF-8 编码：", str_utf8)

print("GBK 编码：", str_gbk)

print("UTF-8 解码：", str_utf8.decode('UTF-8','strict'))

print("GBK 解码：", str_gbk.decode('GBK','strict'))

藕丝空间

UTF-8 编码： b'\xe8\x97\x95\xe4\xb8\x9d\xe7\xa9\xba\xe9\x97\xb4'

GBK 编码： b'\xc5\xba\xcb\xbf\xbf\xd5\xbc\xe4'

UTF-8 解码： 藕丝空间

GBK 解码： 藕丝空间

5.4 bytes.decode(encoding="utf-8", errors="strict")

decode() 方法以指定的编码格式解码 bytes 对象。默认编码为 'utf-8'。

参数

encoding -- 要使用的编码，如"UTF-8"。

errors -- 设置不同错误的处理方案。默认为 'strict',意为编码错误引起一个UnicodeError。 其他可能得值有 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及通过 codecs.register_error() 注册的任何值。

返回值

该方法返回解码后的字符串。

str1 = "藕丝空间";

str_utf8 = str1.encode("UTF-8")

str_gbk = str1.encode("GBK")

print(str1)

print("UTF-8 编码：", str_utf8)

print("GBK 编码：", str_gbk)

print("UTF-8 解码：", str_utf8.decode('UTF-8','strict'))

print("GBK 解码：", str_gbk.decode('GBK','strict'))

藕丝空间

UTF-8 编码： b'\xe8\x97\x95\xe4\xb8\x9d\xe7\xa9\xba\xe9\x97\xb4'

GBK 编码： b'\xc5\xba\xcb\xbf\xbf\xd5\xbc\xe4'

UTF-8 解码： 藕丝空间

GBK 解码： 藕丝空间

5.5 endswith(suffix, beg=0, end=len(string))

参数

suffix -- 该参数可以是一个字符串或者是一个元素。

beg -- 字符串中的开始位置。

end -- 字符中结束位置。

返回值

如果字符串含有指定的后缀返回True，否则返回False。

str1='ousi example....wow!!!'

suffix='!!'

print (str1.endswith(suffix))

print (str1.endswith(suffix,20)) # 从索引 20 的位置开始

suffix1='wow'

print (str1.endswith(suffix1))

print (str1.endswith(suffix1, 0, 19))

True

True

False

True

5. 6 startswith(prefix, beg=0,end=len(string))

参数

prefix -- 检测的字符串。

beg -- 可选参数用于设置字符串检测的起始位置。

end -- 可选参数用于设置字符串检测的结束位置。

返回值

如果检测到字符串则返回True，否则返回False。

str1='ousi example....wow!!!'

prefix='ousi'

print (str1.startswith(prefix))

print (str1.startswith(prefix,20)) # 从索引 20 的位置开始

prefix1='exam'

print (str1.startswith(prefix1))

print (str1.startswith(prefix1, 5, 19))

True

False

False

True

5.7 expandtabs(tabsize=8)

参数

tabsize -- 指定转换字符串中的 tab 符号('\t')转为空格的字符数。

返回值

该方法返回字符串中的 tab 符号('\t')转为空格后生成的新字符串。

str1 = "this is\tstring example....wow!!!"

print ("原始字符串: " + str1)

print ("替换 \\t 符号: " + str1.expandtabs())

print ("使用16个空格替换 \\t 符号: " + str1.expandtabs(16))

原始字符串: this is string example....wow!!!

替换 \t 符号: this is string example....wow!!!

使用16个空格替换 \t 符号: this is string example....wow!!!

5.8 maketrans(intab, outtab)

用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。

两个字符串的长度必须相同，为一一对应的关系。

注：Python3.4已经没有 string.maketrans() 了，取而代之的是内建函数: bytearray.maketrans()、bytes.maketrans()、str.maketrans()

参数

intab -- 字符串中要替代的字符组成的字符串。

outtab -- 相应的映射字符的字符串。

返回值

返回字符串转换后生成的新字符串。

intab = "aeiou"

outtab = "12345"

trantab = str.maketrans(intab, outtab) # 任何一个**已存在**的字符串都可以触发 maketrans命令

str1 = "this is string example....wow!!!"

print (str1.translate(trantab))

th3s 3s str3ng 2x1mpl2....w4w!!!

5.9 translate()

translate()方法语法：

str.translate(table)

bytes.translate(table[, delete])

bytearray.translate(table[, delete])

参数

table -- 翻译表，翻译表是通过 maketrans() 方法转换而来。

deletechars -- 字符串中要过滤的字符列表。

返回值

返回翻译后的字符串,若给出了 delete 参数，则将原来的bytes中的属于delete的字符删除，剩下的字符 要按照table中给出的映射来进行映射 。

intab = "aeiou"

outtab = "12345"

trantab = str.maketrans(intab, outtab) # 任何一个**已存在**的字符串都可以触发 maketrans命令

str1 = "this is string example....wow!!!"

print (str1.translate(trantab))

# -----------

intab = "aeiou".encode("UTF-8")

outtab = "12345".encode("UTF-8")

trantab = bytes.maketrans(intab, outtab)

str2 = "this is string example....wow!!!";

str_utf8 = str2.encode("UTF-8")

print (str_utf8.translate(trantab, 'wow'.encode("UTF-8")))

th3s 3s str3ng 2x1mpl2....w4w!!!

b'th3s 3s str3ng 2x1mpl2....!!!'

5.10 isalnum()

参数

无。

返回值

如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False

str1 = "" # 没有字符

print(str1.isalnum())

str2 = "os373藕丝" # 字符串没有空格

print (str2.isalnum())

str3 = "www.os373.cn " # 存在 . 和空格

print (str3.isalnum())

False

True

False

5.11 isalpha()

参数

无。

返回值

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

str1 = "ousi"

print (str1.isalpha())

str2 = "os373!"

print (str2.isalpha())

True

False

5.12 isdecimal()

isdecimal() 方法检查字符串是否只包含十进制字符。这种方法只存在于 unicode 对象(其它拉丁语言)。

注意:定义一个十进制字符串，只需要在字符串前添加 'u' 前缀即可。

参数

无

返回值

如果字符串是否只包含十进制字符返回True，否则返回False。

str1 = "os373"

print (str1.isdecimal())

str2 = "23443434"

print (str2.isdecimal())

False

True

5.13 isnumeric()

isnumeric() 方法检测字符串是否只由数字组成。这种方法是只针对 unicode 对象(其它拉丁语言)。

参数

无。

返回值

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

str1 = "os373"

print (str1.isnumeric())

str2 = "23443434"

print (str2.isnumeric())

False

True

5.14 isdigit()

参数

无。

返回值

如果字符串只包含数字则返回 True 否则返回 False。

str1 = "01001";

print (str1.isdigit())

str2 = "os373!!!"

print (str2.isdigit())

True

False

5.15 islower()

参数

无。

返回值

如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False

str1 = "os373.cn!!!"

print (str1.islower())

str2 = "http://www.os373.cn\t!!!"

print (str2.islower())

str3 = "http://www.藕丝空间.cn!!!"

print (str3.islower())

str4 = "http://www.OS373.cn!!!"

print (str4.islower())

True

True

True

False

5.16 lower()

参数

无。

返回值

返回将字符串中所有大写字符转换为小写后生成的字符串。

str1 = "OS373.CN!!!"

print (str1.lower())

str2 = "http://WWW.os373.cn\t!!!"

print (str2.lower())

str3 = "http://WWW.藕丝空间.CN!!!"

print (str3.lower())

str4 = "http://WWW.OS373.cn!!!"

print (str4.lower())

os373.cn!!!

http://www.os373.cn !!!

http://www.藕丝空间.cn!!!

http://www.os373.cn!!!

5.17 casefold()

lower() 只对 ASCII 也就是 'A-Z'有效，但是其它一些语言里面存在小写的情况就没办法了。文档里面举得例子是德语中'ß'的小写是'ss'(这个我也不懂)：

s = 'ß'

s.lower() # 'ß'

s.casefold() # 'ss'

5.18 isupper()

参数

无。

返回值

如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False

str1 = "OS373.CN!!!"

print (str1.isupper())

str2 = "http://WWW.os373.cn\t!!!"

print (str2.isupper())

str3 = "http://WWW.藕丝空间.CN!!!"

print (str3.isupper())

str4 = "http://WWW.OS373.cn!!!"

print (str4.isupper())

True

False

False

False

5.19 upper()

参数

无。

返回值

返回小写字母转为大写字母的字符串。

str1 = "OS373.CN!!!"

print (str1.upper())

str2 = "http://WWW.os373.cn\t!!!"

print (str2.upper())

str3 = "http://WWW.藕丝空间.CN!!!"

print (str3.upper())

str4 = "http://WWW.OS373.cn!!!"

print (str4.upper())

OS373.CN!!!

HTTP://WWW.OS373.CN !!!

HTTP://WWW.藕丝空间.CN!!!

HTTP://WWW.OS373.CN!!!

5.20 swapcase()

用于对字符串的大小写字母进行转换。

参数

无。

返回值

返回大小写字母转换后生成的新字符串。

str1 = "OS373.CN!!!"

print (str1.swapcase())

str2 = "http://WWW.os373.cn\t!!!"

print (str2.swapcase())

str3 = "http://WWW.藕丝空间.CN!!!"

print (str3.swapcase())

str4 = "http://WWW.OS373.cn!!!"

print (str4.swapcase())

os373.cn!!!

HTTP://www.OS373.CN !!!

HTTP://www.藕丝空间.cn!!!

HTTP://www.os373.CN!!!

5.21 isspace()

参数

无。

返回值

如果字符串中只包含空格，则返回 True，否则返回 False.

str1 = " "

print (str1.isspace())

str2 = "藕丝空间 "

print (str2.isspace())

True

False

5.22　istitle()

检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写。

参数

无。

返回值

如果字符串中所有的单词拼写首字母为大写，且其他字母为小写则返回 True，否则返回 False.

str1 = "This Is String Example...Wow!!!"

print (str1.istitle())

str2 = "This is string example....wow!!!"

print (str2.istitle())

True

False

5.23 title()

参数

无。

返回值

返回"标题化"的字符串,就是说所有单词都是以大写开始，其它单词为小写。

str1 = "This IS StRING Example...Wow!!!"

print (str1.title())

str2 = "This is string example....藕丝空间，wow!!!"

print (str2.title())

This Is String Example...Wow!!!

This Is String Example....藕丝空间，Wow!!!

5.24 join(seq)

参数

sequence -- 要连接的元素序列。

返回值

返回通过指定字符连接序列中元素后生成的新字符串。

s1 = "-"

s2 = ""

s3 = " "

seq = tuple("os373.cn") # 字符串序列

print (s1.join( seq ))

print (s2.join( seq ))

print (s3.join( seq ))

o-s-3-7-3-.-c-n

os373.cn

o s 3 7 3 . c n

5.25 center(width[, fillchar])

参数

width -- 字符串的总宽度。

fillchar -- 填充字符。

返回值

返回一个指定的宽度 width 且居中的字符串，如果 width 小于字符串宽度直接返回字符串，否则使用 fillchar 去填充。

str1 = "http://www.os373.cn"

print ("str.center(40, '*') : ", str1.center(40, '*'))

print ("str.center(10, '$') : ", str1.center(10, '*'))

str.center(40, '*') : **********http://www.os373.cn***********

str.center(10, '$') : http://www.os373.cn

5.26 ljust(width[, fillchar])

参数

width -- 指定字符串长度。

fillchar -- 填充字符，默认为空格。

返回值

返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。

str1 = "http://www.os373.cn!!!"

print (str1.ljust(50, '*'))

http://www.os373.cn!!!****************************

5.27 rjust(width,[, fillchar])

参数

width -- 指定填充指定字符后中字符串的总长度.

fillchar -- 填充的字符，默认为空格。

返回值

返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串.

str = "http://www.os373.cn!!!"

print (str.rjust(50, '*'))

****************************http://www.os373.cn!!!

5.28 zfill(width)

参数

width -- 指定字符串的长度。原字符串右对齐，前面填充 0。

返回值

返回指定长度的字符串。

str = "http://www.os373.cn!!!"

print (str.zfill(50))

0000000000000000000000000000http://www.os373.cn!!!

5.29 find(str, beg=0 end=len(string))

参数

str -- 指定检索的字符串

beg -- 开始索引，默认为0。

end -- 结束索引，默认为字符串的长度。

返回值

如果包含子字符串，返回开始的索引值，否则返回-1。

str1 = "os373 example....wow!!!"

str2 = "exam";

print (str1.find(str2))

print (str1.find(str2, 5))

print (str1.find(str2, 10))

6

6

-1

5.30 rfind(str, beg=0 end=len(string))

参数

str -- 查找的字符串

beg -- 开始查找的位置，默认为0

end -- 结束查找位置，默认为字符串的长度。

返回值

返回字符串最后一次出现的位置，如果没有匹配项则返回-1。

str1 = "os373 example.... example wow!!!"

str2 = "exam";

print (str1.rfind(str2))

print (str1.rfind(str2, 5))

print (str1.rfind(str2, 20))

18

18

-1

5.31 index(str, beg=0, end=len(string))

参数

str -- 指定检索的字符串

beg -- 开始索引，默认为0。

end -- 结束索引，默认为字符串的长度。

返回值

如果包含子字符串返回开始的索引值，否则抛出异常。

str1 = "os373 example....wow!!!"

str2 = "exam";

print (str1.index(str2))

print (str1.index(str2, 5))

print (str1.index(str2, 10))

6

6

---------------------------------------------------------------------------

ValueError Traceback (most recent call last)

in ()

4 print (str1.index(str2))

5 print (str1.index(str2, 5))

----> 6 print (str1.index(str2, 10))

ValueError: substring not found

5.32 rindex(str, beg=0 end=len(string))

参数

str -- 查找的字符串

beg -- 开始查找的位置，默认为0

end -- 结束查找位置，默认为字符串的长度。

返回值

返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常。

str1 = "os373 example....example wow!!!"

str2 = "exam";

print (str1.rindex(str2))

print (str1.rindex(str2, 5))

print (str1.rindex(str2, 20))

17

17

---------------------------------------------------------------------------

ValueError Traceback (most recent call last)

in ()

4 print (str1.rindex(str2))

5 print (str1.rindex(str2, 5))

----> 6 print (str1.rindex(str2, 20))

ValueError: substring not found

5.33 max(str) 和 min(str)

str1 = "os373"

print("最大字符: " + max(str1)) # 返回字符串中最大的字符

print("最小字符: " + min(str1)) # 返回字符串中最小的字符

最大字符: s

最小字符: 3

5.34 lstrip([chars])

参数

chars --指定截取的字符。

返回值

返回截掉字符串左边的空格或指定字符后生成的新字符串。

str1 = " this is string example....wow!!! ";

print(str1.lstrip());

str2 = "88888888this is string example....wow!!!8888888";

print(str2.lstrip('8'));

this is string example....wow!!!

this is string example....wow!!!8888888

5.35 rstrip([chars])

参数

chars -- 指定删除的字符(默认为空格)

返回值

返回删除 string 字符串末尾的指定字符后生成的新字符串。

str1 = " this is string example....wow!!! ";

print(str1.rstrip());

str2 = "88888888this is string example....wow!!!8888888";

print(str2.rstrip('8'));

this is string example....wow!!!

88888888this is string example....wow!!!

5.36 strip([chars])

参数

chars -- 移除字符串头尾指定的字符。

返回值

返回移除字符串头尾指定的字符生成的新字符串。

str1 = " this is string example....wow!!! ";

print(str1.strip());

str2 = "88888888this is string example....wow!!!8888888";

print(str2.strip('8'));

this is string example....wow!!!

this is string example....wow!!!

5.37 replace(old, new [, max])

参数

old -- 将被替换的子字符串。

new -- 新字符串，用于替换old子字符串。

max -- 可选字符串, 替换不超过 max 次

返回值

返回字符串中的 old(旧字符串) 替换成 new(新字符串)后生成的新字符串，如果指定第三个参数max，则替换不超过 max 次。

str1 = "www.os373.com"

print ("藕丝空间旧地址：", str1)

print ("藕丝空间新地址：", str1.replace("com", "cn"))

str2 = "If you cover your mouth, the worry will run out of your eyes."

print (str2.replace("you", "You", 2)) # 只替换两次

藕丝空间旧地址： www.os373.com

藕丝空间新地址： www.os373.cn

If You cover Your mouth, the worry will run out of your eyes.

5.38 split(str="", num=string.count(str))

参数

str -- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。

num -- 分割次数。

返回值

返回分割后的字符串列表。

str1 = "this is string \r example\n....wow!!!"

print (str1.split())

print (str1.split('i',1))

print (str1.split('w'))

['this', 'is', 'string', 'example', '....wow!!!']

['th', 's is string \r example\n....wow!!!']

['this is string \r example\n....', 'o', '!!!']

5.39 splitlines([keepends])

参数

keepends -- 在输出结果里是否去掉换行符('\r', '\r\n', \n')，默认为 False，不包含换行符，如果为 True，则保留换行符。

返回值

返回一个包含各行作为元素的列表。

str1 = 'ab c\n\nde fg\rkl\r\n'

print(str1.splitlines())

print(str1.splitlines(True))

['ab c', '', 'de fg', 'kl']

['ab c\n', '\n', 'de fg\r', 'kl\r\n']