Python程序设计——字符串处理的特殊方法

学习目标：

1. 学习如何创建字符串
2. 使用len、min和max函数获取一个字符串的长度、串中的最大和最小的字符
3. 使用下标运算符([])访问字符串中的元素
4. 使用截取运算符str[ start:end]从较长的字符串中得到一个子串
5. 使用+运算符连接两个字符串，通过*运算符复制一个字符串
6. 使用in和not in运算符判断一个字符串是否包含在另一个字符串内
7. 使用比较运算符(==、! =、<、<=、>、>=)对字符串进行比较
8. 使用for循环迭代字符串中的字符
9. 使用方法isalnum、isalpha、isdigit、isidentifier、islower、isupper 和isspace来测试字符串
10. 使用方法endswith、startswith、find、rfind 和count搜索子串
11. 使用方法capitalize、lower、upper、title、swapcase和replace 转换字符串
12. 使用方法lstrip、rstrip 和strip从一个字符串的左侧或右侧删除空格
13. 使用方法center、ljust、rjust 和format格式化字符串
14. 在应用程序( CheckPalindrome、Hex ToDecimalConversion)的开发过程中应用字符串
15. 为运算符定义特殊的方法
16. 设计Rational类表示有理数

一、引言

        关键点:本章将重点放在类的设计上，它使用Python中的str类为例并探索Python中特殊方法的作用。

        前一篇介绍了关于类和对象的一些重要概念。我们已经学习了如何定义一个类，以及如何创建和使用对象。str 类不仅在表示字符串方面很有用，而且它也是一个很好的类设计的例子。本文我们将更深人地讨论str类。在Python语言中特殊方法起着非常重要的作用。这里也会介绍一些特殊方法和运算符重载，以及使用特殊方法设计类。

二、str 类

关键点：一个str对象是不可变的;这也就是说，一旦创建了这个字符串，那么它的内容是不可变的。

2.1、创建字符串

你可以使用构造函数构建字符串，如下所示:

s1 = str() # Create an empty string object
s2 = str("Welcome") # Create a string object for We lcome

Python提供了一个简单语法，它通过使用字符串值创建一一个字符串。例如:

s1 = " "# Same as s1= str()
s2 = "Welcome" # Same as s2 = str("Welcome")

        一个字符串对象是不可变的: 一旦创建一个字符串对象出来，那么它的内容就不会再改变。为了优化性能，Python 使用一个对象来表示具有相同内容的字符串。如图所示，s1和s2都指向同一个字符串对象，它们都有着相同的id数。

        这个动作对Python库中的所有不可变对象都是真的。例如: int 是一种不可变类。两个具有相同值的int对象实际上是共享了相同的对象，如图所示：

2.2、处理字符串的函数

        Python的一些内置函数可以和字符串一起使用。你可以使用len函数来返回一个字符串中的字符个数，而max和min函数返回字符串中的最大和最小字符。下面是一些例子:

>>> S = "We1come"
>>> len(s)
7
>>> max(s)
'o'
>>> min(s)
'W'
>>>

        因为字符串s有7个字符，len(s)返回7 。注意:小写字母的ASCII码值要高于小写字母的ASCII码值，所以，max(s) 返回o ，而min(s)返回W 。

2.3、下标运算符 [ ]

一个字符串是一个字符序列。可以使用下面的语法通过下标运算符访问字符串中的一个字符：

s[index]

下标是基于0的;也就是说，它们的范围从0到len(s)-1，如图所示。

2.4、截取运算符 [start : end]

        截取运算符通过使用语法s[start:end]返回字符串其中的一段。这一段就是从下标start到下标end-1的一个子串。例如：

>>> s = "Welcome"
>>> s[1 : 4]
elc

s[1:4]返回从下标1到下标3的子串。

        起始下标或结束下标都可以被忽略。在这种情况下，默认的起始下标是0，而结束下标是最后一个下标。例如：

>>> S = "Welcome"
>>>s[ :6]
'Welcom'
>>> s[4: ]
'ome'
>>>s[1:-1]
elcom
>>>

        在第2行中，s[ :6] 和s[0:6]是一样的，都返回的是从下标0到下标5的子串。在第4行中，s[4: ]和s[4:7]是一样的，都返回的是从下标4到下标6的子串。你也可以在截取字符串的过程中使用负下标。例如，在第6行中，s[1:-1] 和s[1:-1+len(s)]是一样的。

        注意:如果截取操作s[i:j] 中的下标(i或j)是负数，那么就用len(s)+index来替换下标。如果j>len(s)，那么j就会被设置成len(s)。如果i>=j，那么截取的子串就会成为空串。

2.5、连接运算符+和复制运算符*

        你可以使用连接运算符+组合或连接两个字符串。你也可以使用复制运算符*来连接相同的字符串多次。下面是一 些例子:

>>> s1 = "Welcome"
>>> s2 = "Python"
>>> s3 = s1 + "to" + s2
>>> s3
'Welcome to Python'
>>> s4 = 3 * s1
>>> s4
'WelcomeWelcomeWelcome'
>>> s5 = s1 * 3
>>>s5
'WelcomeWelcomeWelcome'
>>>

注意: 3*s1和s1*3具有相同的效果。

2.6、in和notin运算符

你可以使用in和not in操作来测试一个字符串 是否在另一个字符串中。下面是一些例子:

>>> s1 = "Welcome" 
>>> "come" in s1
True
>>> "come" not in s1
False
>>>

下面是另一个例子:

s = input("Enter a string: ")
if "Python" in s:
    print("Python"，"is in"， s)
else:
    print("Python"，"is not in"， s)

        如果你在运行这个程序的时候将字符串“WelcometoPython”作为输入，这个程序就应该显示:
        python is in Welcome to Python.

2.7、比较字符串

        你可以使用比较运算符来对字符串进行比较(已经介绍过==、!=、 >、<. >=和<=)。Python是通过比较字符串中对应的字符进行比较的，比较是通过计算字符的数值代码实现的。例如，a比A大，因为a的数值代码比A的数值代码大。

        假设你需要比较字符串s1("Jane")和s2("Jake")。首先，比较s1和s2中的首字符(J和J)。因为它们是一样的，所以比较它们的第二个字符(a和a)。因为它们也是一样的，所以比较它们的第三个字符(n 和k)。因为n的ASCII码值要大于k的，所以s1是大于s2的。

        下面是一些例子:

>>>'green' == 'glow'
False
>>> "green" != "g1ow"
True
>>> "green" > "glow"
True
>>> "green" >= "glow"
True
>>> "green" < "g1ow"
False
>>> "green" <= "g1ow"
False
>>> "ab" <= "abc"
True
>>>

2.8、迭代字符串

        一个字符串是可迭代的。这意味着你可以使用一个for循环来顺序遍历字符串中的所有字符。例如，下面的代码显示了字符串s中的所有字符:

for ch in s:
    print(ch)

你可以将这段代码读作“对于s中的每个字符ch,都打印ch”。

        这个for循环没有使用下标来访问字符。但是，如果你想以不同顺序遍历字符，那么你仍然必须使用下标。例如，下面的代码显示了字符串奇数位置的字符:

for i in range(0, len(s), 2):
    print(s[i])

        这段代码使用变量i作为字符串s的下标。i的初始值是0，然后，在它达到或超过len(s)之前每次增加2。对于每个i值，都打印s[i]。

2.9、测试字符串

2.10、搜索字串

2.11、转换字符串

 注意：如同之前所述，字符串是不可变的。str 类中没有方法能改变字符串的内容，这些方法都是创建了新的字符串。

2.12、删除字符串中的空格

        你可以使用下图中的方法从字符串的前端、末端或者两端来删除字符串中的空格。回
顾一下，字符' '、\t、\f、\r和\n都被称作空白字符。

        注意：删除空白字符的方法只能去掉字符串前后两端的空白字符，并不能删除被非空白字符包围的空白字符。

        提示：在输入字符串上应用strip()方法来确保删除输入的末尾任何不需要的字符，这是很好的经验。

2.13、格式化字符串

 下面是使用center、ljust和rjust方法的一些例子:

>>> s = "Welcome"
>>> s1 = s.center(11)
>>>s1
'  Welcome  '
>>> s2 = s.ljust(11)
>>>>s2
'Welcome       '
>>> s3 = s.rjust(11)
>>;>>s3
'      Welcome '
>>>

        在第2行，s.center(11)将字符串s放在占位11个字符的字符串中央。在第5行，s.ljust(11)将字符串s放在占位11个字符的字符串左端。在第8行，s.rjust(11) 将字符串s放在占位11个字符的字符串右端。

三、运算符重载和特殊方法

关键点: Python允许为运算符和函数定义特殊的方法来实现常用的操作。Python使用一种独特方式来命名这些方法以辨别它们的关联性。

        在之前，我们已经学会了如何使用完成字符串操作的运算符。可以使用运算符+来结合两个字符串，而运算符*可以结合同一字符串多次，关系运算符(==、!=.<.<=、>、>=)用来比较两个字符串，而下标运算符[]用来访问一个字符。例如:

s1 ="Washi ngton"
s2 = "Cali fornia"
print("The first character in s1 is"，s1[0] )
print("s1+s2is",s1+s2)
print("s1 < s2?"，s1 < s2 )

        这些运算符实际。上都是在str类中定义的方法。为运算符定义方法被称作运算符重载。运算符重载允许程序员使用内嵌的运算符为用户定义方法。下表罗列出运算符和方法之间的映射关系。当你命名这些方法时，名字前后要加两个下划线以便于Python辨识它们的关联性。例如：为了将运算符+作为方法来使用，你应当定义一个名为__ add__ 的方法。 注意:这些方法并不是私有的，因为它们除了两个起始下划线还有两个结尾下划线。回顾一下，类中的初始化程序被命名为__ init__ ，这是一个初始化对象的特殊方法。

例如，你可以使用如下方法改写之前的代码:

s1 = "Washington"
s2 = "California"
print("The first character in sl is", s1.__ getitem__(0) )
print("s1 + s2 is", s1.__add__ (s2))
print("s1 < s2?", s1.__lt_ __ (s2))

        s1.__ getitem__ (0) 与s1[0]相同，sl.__ add__ (s2) 与s1+s2相同，而s1.__ lt__ (s2) 与s1<s2相同。现在，你可以看出重载运算符的优势。重载运算符可以极大地简化程序，让程序更易读、易维护。

        Python支持in运算符，它可以用来判断一个字符是否在另一个字符串中或者一个元素是否是一个容器中的成员。对应的方法被命名为__ contains__(self,e)。 你可以使用方法__contain__或使用 in运算符来判断一个字符是否在一个字符串内，代码如下所示。

1 s1 = "Washi ngton"
2 print("Is W in s1?"， 'W' in s1 )
3 print("Is W in s1?"， s1.__contains__('W') )

W in s1和s1.__ contains__('w')一样。

如果一个类定义了__ len__ (self) 方法，那么Python允许你使用方便的语法将调用方法作为函数调用。例如：__ len__ 方法被定义在 str类中，该方法返回字符串的字符个数。你既可以使用__ len__ 方 法也可以使用len函数来获取字符串中的字符个数，代码如下所述:

1 s1 = "Washington"
2 print("The 1ength of s1 is"， 1en(s1))
3 print("The 1ength of s1 is", s1.__1en__())

len(s1)和s1.__ len__ () 是相同的。

        许多特殊的运算符都被定义为Python的内置类型，例如: int 和float。假设i是3而j是4。i.__add__ (j) 和i+j是相同的，而i.__sub__(j) 和i-j是相同的。

注意：你可以传递一个对象 去调用print(x)。 这等价于调用print(x.__ str__()) 或 print(str(x))。

        注意：比较运算符(==、!=、<、<=、>和>=)也可以通过使用方法__ cmp__ (self,other)来实现。如果self<other,那么该方法返回负整数。如果self==other，那么该方法返回0。如果self>other, 那么该方法返回正整数。对于两个对象a和b，如果__ It___ 可用的话，那么a<b就调用a.__ It__(b)。 如果不行的话就调用__cmp__ 方法 来决定顺序。

四、总结

• 字符串对象是不可变的，不可以改变它的内容。
• 可以使用Python函数len、min和max来返回字符串的长度、最大元素和最小元素。
• 可以使用下标运算符[]来指向字符串中的一个单独的字符。
• 可以使用连接运算符+来连接两个字符串，使用复制运算符*来复制一个字符串多次，使用截取运算符[: ]来获取子串，而使用运算符in和not in来判断-一个字符是否在一个字符串中。
• 使用比较运算符(==、!=、 <、<=、>和>=)比较两个字符串。
• 使用for循环迭代字符串中的所有字符。
• 可以在字符串对象上使用像endswith、startswitch、 isalpha、 islower、 isupper、lower、 upper、 find 、count、replace和strip这样的函数。
• 可以为重载操作定义特殊方法。