python中的real函数_RealPython基础教程：Python字符串⽤
法详解
字符串是⼀个由字符数据组成的序列。字符串处理是编程必备的技能，很少有应⽤程序不需要操作字符串的。
Python 提供了丰富的运算符、函数和类⽅法来操作字符串。
通过本⽂，你将了解如何访问字符串以及提取字符串的⼦串，并熟悉⽤于操作和修改字符串数据的⽅法。
我们也会向你介绍 Python 中另外两种表⽰裸字节数据的对象：bytes 和 bytearray。
【字符串操作】
下边，我们将着重介绍⽤于字符串操作的运算符、类⽅法和函数。
1，字符串运算符
在《Python 运算符和表达式》⼀⽂中，我们已经在算术运算中使⽤过 + 和 * 运算符。这两个运算符不仅
适⽤于数字操作数，它们也可⽤于字符串。
+ 运算符⽤于连接字符串，它返回⼀个由所有操作数连接在⼀起的字符串。>>> s = 'foo'>>> t = 'bar'>>> u = 'baz'>>>>>> s + t'foobar'>>> s + t + u'foobarbaz'>>>>>> print('Go team' + '')Go team
* 运算符⽤于创建⼀个字符串的多份拷贝，并将这些拷贝连接起来。
若 s 是⼀个字符串，n 是⼀个整数，下边两个表达式均会返回连接起来的字符串 s 的 n 份拷贝。s * nn * s
例如：>>> s = 'foo.'>>> s * 4'foo.foo.foo.foo.'>>> 4 * s'foo.foo.foo.foo.'
这⾥，n 必须为⼀个整数。你可能会觉得 n 还得必须为正整数，事实是，它可以是 0 或者 负数，这时候计算结果为空字符串。>>> 'foo' * -8''
Python 提供了⼀个可⽤于字符串的成员关系运算符：in。
若 in 运算符的左操作数包含于右操作数中，in 返回 True，否则返回 False。>>> s = 'foo'>>> s in "That's food for thought"True>>> s in "That's good for now"False
Python 还提供了 not in 运算符，含义正好和 in 相反。>>> 'z' not in 'abc'True>>> 'z' not in 'xyz'False
2，内置字符串函数
Python 提供了很多内置函数，可⽤于字符串操作。⽐如：函数描述
chr()将整数转化为字符
ord()将字符转化为整数
len()返回字符串的长度
str()返回⼀个对象的字符串表⽰
我们逐⼀了解⼀下这⼏个函数。
ord(c)：返回字符的整数值
从最基本层⾯来讲，计算机是以数字的形式存储所有信息的。为了表⽰字符数据，我们可以⽤⼀个模式来翻译字符和对应数字之间的映射关系。
通常使⽤的最简单的模式就是 ASCII。它覆盖了我们最习惯使⽤的常见的拉丁字符。对于这些字符，ord(c) 返回字符 c 的 ASCII 值。>>> ord('a')97>>> ord('#')35
从本教程开始到现在，ASCII 很好地满⾜了我们的需求。但世界上还存在很多其他语⾔，在数字媒体领域也包含⽆数的符号。因此，需要⽤计算机编码表⽰的完整的字符集规模远超普通拉丁字符、数字和常见符号。
Unicode 编码标准在这⽅⾯雄⼼勃勃，它试图提供⼀个覆盖所有字符、所有语⾔、所有平台的数字编码集。docker的优势
Python 3 对 Unicode 提供了⼴泛的⽀持，允许你在字符串中使⽤ Unicode 字符。
只要你使⽤范围限于普通字符，ASCII 和 Unicode 并⽆实操上的区别。⽽对于 Unicode 字符，ord(c) 函数也会返回其数字值。>>>
ord('€')8364>>> ord('∑')8721
chr(n)：返回整数的字符值
chr() 和 ord() ⽤途恰好相反。对于⼀个给定的数字，chr(n) 返回⼀个字符串，其值为和 n 对应的字符。>>> chr(97)'a'>>> chr(35)'#'
chr() 也可处理 Unicode 字符。>>> chr(8364)'€'>>> chr(8721)'∑'
len(s)：返回字符串的长度
python基础教程书在线阅读你可以使⽤ len() 来检查字符串的长度，len(s) 返回字符串 s 中 字符的个数。>>> s = 'I am a string.'>>> len(s)14
str(obj)：返回⼀个对象的字符串表⽰
Python 中的每个对象都可使⽤字符串来表⽰，str(obj) 返回对象 obj 的字符串表⽰。>>> str(39.2)'39.2'>>> str(3+4j)'(3+4j)'>>> str(3 + 29)'32'>>> str('foo')'foo'
3，字符串索引
在编程语⾔⾥，有序数据集中的单个元素通常可以直接通过数字索引或键值来访问。这个过程就是指索引(indexing)。
Python 中的字符串是字符数据的有序序列，因此可以⽤这种⽅式建⽴索引。字符串中的单个字符可通过字符串名称加⽅括号([])的⽅式来访问，⽅括号中是⼀个数字，即字符在字符串中的位置。
Python 中字符串索引以 0 开始。字符串中第⼀个字符的索引为 0，下⼀个索引为 1，以此类推。最后⼀个字符的索引为字符串长度减 1.
⽐如：字符串 'foobar' 的索引简图可表⽰为：
每个字符可通过如下⽅式来访问：>>> s = 'foobar'>>> s[0]'f'>>> s[1]'o'>>> s[3]'b'>>> len(s)6>>> s[len(s) - 1]'r'
索引范围超出字符串尾部，将会导致错误：>>> s[6]Traceback (most recent call last):File "", line 1, in IndexError: string index out of range
这种情况称为“访问越界”。
字符串索引值也可以为负数，这种情况下索引就是⾃字符串尾部倒着进⾏：-1 指向最后⼀个字符，-2 指向倒数第⼆个字符，以此类推。
下图展⽰了在字符串 'foobar' 上同时使⽤正值索引和负值索引的情况：
看⼀些负值索引的例⼦：>>> s = 'foobar'>>> s[-1]'r'>>> s[-2]'a'>>> len(s)6>>> s[-len(s)]'f'
负值索引若超出字符串⾸部也会报错：>>> s[-7)File "", line 1s[-7)^SyntaxError: invalid syntax
对于任何⾮空字符串，s[len(s)-1] 和 s[-1] 均返回最后⼀个字符。
对空字符串进⾏索引访问没有任何意义。
4，字符串切⽚
字符串切⽚是 Python 提供的⼀种索引语法格式，⽤于从字符串中提取⼦串。
若 s 是⼀个字符串，表达式 s[m:n] 返回⼀个 s 的⼦字符串，该字符串起始于 s 的索引为 m 的位置，终⽌于但不含索引为 n 的位置。>>> s = 'foobar'>>> s[2:5]'oba'
这个例⼦中，第⼆个索引(5)指向了字符串 'foobar' 的第⼀个不包含在⼦串中的字符 'r'(s[5])。
这似乎和直观认识有点不符，但这种表⽰⽅法有其有意义的地⽅：表达式 s[m:n] 返回了⼀个长度为 n-m 的⼦串，你能⼀眼就看出⼦串的长度。上边例⼦⾥，⼦串的长度就是 5-2=3.
表达式 s[m:n] 的第⼀个索引 m 可以被省略，省略后切⽚就从字符串 s 的第⼀个字符开始，即 s[:n] 等同于 s[0:n]。>>> s = 'foobar'>>> s[:4]'foob'>>> s[0:4]'foob'
与之类似，第⼆个索引 n 也可以被省略，省略后切⽚会⾃动从第⼀个索引位置扩展到字符串结尾。s[m:] 和 s[m:len(s)] 效果相同，但显然⽐后者更友好简洁。>>> s = 'foobar'>>> s[2:]'obar'>>> s[2:len(s)]'obar'
对于任何⼀个字符串 s 和 任何整数 n( 0≤n≤len(s) )，s[:n] + s[n:] == s。>>> s = 'foobar'>>> s[:4] + s[4:]'foobar'>>> s[:4] + s[4:] == sTrue
若省略 s[m:n] 的两个索引，即 s[:]，表达式将会返回原来的字符串。这个返回值并⾮原字符串的拷贝，它是对原字符串的引⽤。>>> s = 'foobar'>>> t = s[:]>>> t'foobar'>>> id(s)1933478254320>>> id(t)1933478254320>>> t is sTrue
若切⽚表达式的第⼀个索引⼤于等于第⼆个索引，Python 将返回⼀个空字符串。>>> s[2:2]''>>> s[4:2]''
和访问字符串中的单个字符⼀样，负值索引也可以应⽤到字符串切⽚表达式中。
下图展⽰了如何从字符串 ‘foobar’ 中提取⼦串 'oob'，图中分别标注了使⽤正值索引和负值索引两种情形。
看⼀下相应的 Python 代码：>>> s = 'foobar'>>> s[-5:-2]'oob'>>> s[1:4]'oob'>>> s[-5:-2] == s[1:4]True
5，指定切⽚步长
切⽚表达式的语法还有⼀种情况需要探讨，就是，再增加⼀个冒号和⼀个参数 step，即：s[m:n:step]。step 为步长，表⽰每获取⼀个字符后，在字符串中⾏进的距离。
⽐如，对于字符串 'foobar'，切⽚ 0:6:2 表⽰从第⼀个字符开始，每隔⼀个字符取下⼀个字符，直到最后⼀个字符。可⽤下图表⽰：
⽤代码表⽰为：>>> s = 'foobar'>>> s[0:6:2]'foa'
你同样可以省略表达式中前两个索引，Python 解释器会默认取第⼀个和最后⼀个字符：>>> s = '12345' * 5>>>
s'1234512345123451234512345'>>> s[::5]'11111'>>> s[4::5]'55555'
步长可以为负值，这种情况下，Python 会倒序遍历字符串，此时要求第⼀个(起始)索引值要⼤于第⼆个(结束)索引值。>>> s =
'foobar'>>> s[5:0:-2] #从最后⼀个字符开始倒序每隔⼀个字符取下⼀个字符直到(不含)⾸字符'rbo'
当倒序步进访问字符串时，若省略前两个索引参数，这两个参数的默认取值将分别是末字符和⾸字符的索引。⽐如：>>> s = '12345' * 5>>> s'1234512345123451234512345'>>> s[::5]'11111'>>> s[::-5]'55555'
这可⽤于翻转⼀个字符串：>>> s = 'If Comrade Napoleon says it, it must be right.'>>> s[::-1]'.thgir eb tsum ti ,ti syas noelopaN edarmoC fI'
6，将变量插⼊到字符串中
Python 3.6 引⼊了⼀种新的字符串格式化机制。该机制名为“格式化的字符串字⾯量”，通常也叫做 f-string。
f-string 拥有很多特性，我们会在后续⽂章中进⾏专题介绍，这⾥不作详细展开。
不过，你现在可以使⽤⼀个 f-string 的简单特性：变量插值。
f-string 字⾯量允许你在其中直接指定变量名称，Python 解释 f-string 形式的字符串时，会⽤变量的值来替代变量名称。
假设你要显⽰⼀个算术运算的结果，你可以直接通过 print() 语句来输出，在 print() 中使⽤逗号来分隔数字值和字符串常量。>>> n = 20>>> m = 25>>> prod = n * m>>> print('The product of', n, 'and', m, 'is', prod)The product of 20 and 25 is 500
这种写法有些笨拙。我们可以使⽤ f-string 来实现同样的⽬的：在字符串常量的上引号前添加⼀个⼤写 F 或⼩写 f，指⽰ Python 解释器这是⼀个 f-string，⽽⾮⼀个普通字符串
使⽤⼤括号({})在 f-string 中插⼊任意变量
使⽤ f-string 来转换上边那段代码，会显得更清晰些：>>> n = 20>>> m = 25>>> prod = n * m>>> print(f'The prod of {n} and {m} is {prod}')The prod of 20 and 25 is 500
定义 Python 字符串的三种形式的引号都可以⽤来定义 f-string：>>> var = 'Bark'>>> print(f'A dog says {var}')A dog says Bark>>> print(f"A dog says {var}")A dog says Bark>>> print(f'''A dog says {var}''')A dog says Bark
7，修改字符串
简单说，我们⽆法修改⼀个字符串。字符串是 Python 中的⼀种不可变数据类型。
事实上，我们⽬前接触到的这些数据类型都是不可变的。当然，Python 也提供了其他可变数据类型，我们很快就会学习这些类型。
如果你尝试修改字符串的内容，你会得到如下报错：>>> s = 'foobar'>>> s[3] = 'x'Traceback (most recent call last):File "", line 1, in TypeError: 'str' object does not support item assignment
⽽实际中，你也没必要⾮得修改字符串。你可以轻松⽣成字符串的⼀份拷贝，并在拷贝过程中完成字符串内容的修改。
Python 中有很多⽅法可以完成这项功能。下边是⼀种可能的⽅法：>>> s = s[:3] + 'x' + s[4:]>>> s'fooxar'
这也可以通过⼀个内置的字符串类⽅法来实现：>>> s = 'foobar'>>> s = s.replace('b', 'x')>>> s'fooxar'
我们接着来了解这些内置的字符串类⽅法。
8，内置字符串类⽅法
我们知道，Python 是⼀个⾼度⾯向对象的语⾔，Python 程序中的每个数据元素都是⼀个对象。
你也熟悉了 Python 中的函数，它们是可供调⽤的⽤于执⾏特定任务的过程。
⽅法和函数近似。它是⼀个特定类型的可调⽤过程，和对象紧密相连。
⽅法也⽤于执⾏特定的任务，但⽅法只能通过对象来调⽤，它在执⾏过程中对⽬标对象了如指掌。
调⽤作⽤于对象的⽅法的语法为：obj.foo()
这将在 对象 obj 上调⽤ .foo() ⽅法， 为传递给该⽅法的参数，如果有的话。
我们会在后续讨论⾯向对象编程时学习更多定义和调⽤类⽅法的知识。此处，我们仅了解⼀些常⽤的字符串操作相关的⽅法。
下边按⽤途分别介绍这些字符串类⽅法，其中，中括号中的参数表明这些参数是可选的。
8.1，⼤⼩写转换
s.capitalize()：将⽬标字符串的⾸字母转为⼤写字符，其他字符转为⼩写字符，⾮字母字符保持不变。>>> s = 'foO BaR BAZ quX'>>> s.capitalize()'Foo bar baz qux'>>>>>> s = 'foo123#BAR#.'>>> s.capitalize()'Foo123#bar#.'
s.lower()：将字母字符转为⼩写>>> 'FOO Bar 123 baz qUX'.lower()'foo bar 123 baz qux'
s.swapcase()：切换字母字符的⼤⼩写>>> 'FOO Bar 123 baz qUX'.swapcase()'foo bAR 123 BAZ Qux'
s.title()：将字符串中每个单词的⾸字母转为⼤写，其他字母转为⼩写>>> 'the sun also rises'.title()'The Sun Also Rises'
此⽅法使⽤的是很简单的算法，不区分单词的重要性，也没有妥善处理⼀些符号。>>> "what's happened to ted's IBM
stock?".title()"What'S Happened To Ted'S Ibm Stock?"
s.upper()：将字母字符转为⼤写>>> 'FOO Bar 123 baz qUX'.upper()'FOO BAR 123 BAZ QUX'
8.2，查与替换
怎么查看jdk的安装目录>关于超链接的说法正确的是本组中的类⽅法提供了各种在⽬标字符串中搜索⼦串的⽅法。每个类⽅法都⽀持可选的 和 参数，这两个参数⽤作字符串切⽚：⽅法仅在[start, end) 范围内对⽬标字符串执⾏搜索。如果指定了 ⽽没有指定 ，搜索范围就是⾃ start 指向的位置直到字符串结尾。
api网关和微服务网关
'foobar'.endswith('oob', 0, 4)True>>> 'foobar'.endswith('oob', 2, 4)False
s.find([, [, ]])：查⼦串。若到，返回⼦串的最⼩索引值；否则，返回 -1>>> 'foo bar foo baz foo qux'.find('foo')0>>> 'foo bar foo baz foo qux'.find('grault')-1>>> 'foo bar foo baz foo qux'.find('foo', 4)8>>> 'foo bar foo baz foo qux'.find('foo', 4, 7)-1
s.index([, [, ]])：同 s.find()，若未到抛异常>>> 'foo bar foo baz foo qux'.index('grault')Traceback (most recent call last):File "", line 1, in ValueError: substring not found
s.rfind([, [, ]])：从尾端开始查⼦串。若到，返回⼦串的最⼤索引值；否则，返回 -1>>> 'foo bar foo baz foo qux'.rfind('foo')16>>> 'foo bar foo baz foo
qux'.rfind('grault')-1>>> 'foo bar foo baz foo qux'.rfind('foo', 0, 14)8>>> 'foo bar foo baz foo qux'.rfind('foo', 10, 14)-1
s.rindex([, [, ]])：同 s.rfind()，若未到抛异常>>> 'foo bar foo baz foo qux'.rindex('grault')Traceback (most recent call last):File "", line 1, in ValueError: substring not found
s.startswith([, [, ]])：判断是否以给定的⼦串开头>>> 'foobar'.startswith('foo')True>>> 'foobar'.startswith('bar')False>>>
'foobar'.startswith('bar', 3)True>>> 'foobar'.startswith('bar', 3, 2)False
8.3，字符分类
s.isalnum()：判断字符串是否完全由字母或数字组成>>> 'abc123'.isalnum()True>>> 'abc$123'.isalnum()False>>> ''.isalnum()False
s.isalpha()：判断字符串是否完全由字母组成>>> 'ABCabc'.isalpha()True>>> 'abc123'.isalpha()False
s.isdigit()：判断字符串是否完全由数字组成>>> '123'.isdigit()True>>> '123abc'.isdigit()False
s.isidentifier()：判断字符串是否是⼀个合法的 Python 标识符，即是否符合 Python 标识符命名规范。>>> 'foo32'.isidentifier()True>>> '32foo'.isidentifier()False>>> 'foo$32'.isidentifier()False
若字符串为 Python 关键字，尽管不是合法标识符，此函数亦返回 True：>>> 'and'.isidentifier()True
若你想测试字符串是否为 Python 关键字，可调⽤ keyword 模块中的 iskeyword() 函数：>>> from keyword import iskeyword>>> iskeyword('and')True
这样，可结合 s.isidentifier() 和 keyword.iskeyword() 来判断字符串是否为⼀个真正合法的标识符：>>> 'and'.isidentifier() and not iskeyword('and')False>>> 'apple'.isidentifier() and not iskeyword('apple')True
s.islower()：判断字符串中的字母字符是否全为⼩写字母>>> 'abc'.islower()True>>> 'abc1$d'.islower()True>>>
'Abc1$D'.islower()False
s.isprintable()：判断字符串中的字母字符是否全为可打印字符>>> 'a\tb'.isprintable()False>>> 'a b'.isprintable()True>>>
''.isprintable()True>>> 'a\nb'.isprintable()False
s.isspace()：判断字符串中的字符是否全为空⽩字符，常见的空⽩字符为' '、'\t' 和 '\n'>>> ' \t \n '.isspace()True>>> ' a '.isspace()False
s.istitle()：判断字符串是否为 title 形式的⼤⼩写，参上⽂ s.title()>>> 'This Is A Title'.istitle()True>>> 'This is a title'.istitle()False>>>
'Give Me The #$#@ Ball!'.istitle()True
s.isupper()：判断字符串中的字母字符是否全为⼤写字母>>> 'ABC'.isupper()True>>> 'ABC1$D'.isupper()True>>>
'Abc1$D'.isupper()False
8.4，字符串格式化
<([, ])：将字符串居中到⼀个指定宽度的字段，可设置填充字符，默认使⽤空格填充>>> 'foo'.center(10)' foo '>>> 'bar'.center(10, '-')'---bar----'
若 s 长度超过设置的宽度，s 保持不变：>>> 'foo'.center(2)'foo'weblogic端口配置文件
'a\tb\tc'.expandtabs(4)'a b c'
s.ljust([, ])：将字符串左对齐到⼀个指定宽度的字段，可设置填充字符，默认使⽤空格填充>>> 'foo'.ljust(10)'foo '>>> 'foo'.ljust(10, '-')'foo-------'>>> 'foo'.ljust(2)'foo'
s.lstrip([])：移除字符串左侧指定的字符，默认移除空⽩字符>>> ' foo bar baz '.lstrip()'foo bar baz '>>>
'\t\nfoo\t\nbar\t\nbaz'.lstrip()'foo\t\nbar\t\nbaz'>>> 'alpython'.lstrip('/:pth')'alpython'

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。