Python中的字符串 - 多情俏狐

Python中的字符串

一个字符串，包含单\'\'引号（""）或双引号（）标记中的字符序列。这里是你如何在Python中创建字符串。

>>>

>>> s1 = \'String in single quotes\'

>>> s1

\'String in single quotes\'

>>>

>>> s2 = "String in double quotes"

>>> s2

\'String in double quotes\'

>>>

>>> \'hello everyone\'

\'hello everyone\'

>>>

>>> "hello everyone"

\'hello everyone\'

>>>

在Python Shell或IDLE中，字符串始终使用单引号显示。但是，如果使用该print()函数，则只显示该字符串的内容。

>>>

>>> print(s1)

String in single quotes

>>> print(s2)

String in double quotes

>>>

一些像C，C ++，Java这样的语言将单个字符视为一种称为特殊类型的字符char，但在Python中，单个字符也是一个字符串。

>>>

>>> achar = \'a\' # string containing a single character

>>> type(achar)

>>>

>>> type("a string") # string containing multiple characters

>>>

使用len（）函数计算字符数＃

在len()内置函数计算字符串中的字符数。

>>>

>>> len("a string")

>>>

>>> s = "a long string"

>>>

>>> len(s)

>>>

>>> len("")

>>>

创建空字符串＃

>>>

>>> s3 = \'\' # empty string using single quotes

>>> s3

\'\'

>>>

>>> s4 = "" # empty string using double quotes

>>> s4

\'\'

>>>

虽然变数s3和s4不包含任何字符，它们仍然是有效的字符串。您可以使用该type()功能验证这一事实。

>>>

>>> type(s3)

>>>

>>> type(s4)

>>>

那么我应该在创建字符串时使用单引号还是双引号？

双引号在字符串中有单引号时派上用场。例如：

>>>

>>> print("I\'m learning python")

I\'m learning python

>>>

如果我们使用了单引号，我们会得到以下错误：

>>>

>>> print(\'I\'m learning python\')

File "<stdin>", line 1

print(\'I\'m learning python\')

SyntaxError: invalid syntax

>>>

这里的问题在于Python解释器认为字符后面的第二个引号标记I了字符串的末尾，并且不知道如何处理其他字符。

同样，如果您想要在一个字符串内打印双引号，只需将整个字符串包装在单引号内而不是双引号内。

>>>

>>> print(\'John says "Hello there !"\')

John says "Hello there !"

>>>

还有一种方法是使用Escape Sequence在字符串中嵌入单引号或双引号，这将在下面讨论。

转义序列＃

转义序列是一组特殊字符，用于打印无法使用键盘直接输入的字符。每个转义序列都以反斜杠（\）字符开头。

下表列出了一些常见的转义序列。

转义序列	含义
\n	换行符 - 打印换行符
\t	标签 - 打印制表符
\\	反斜线 - 打印反斜杠（\）字符
\\'	单引号 - 打印单引号
\"	双引号 - 打印双引号

当字符串内部使用转义序列时，Python将它们视为特殊命令。例如，\t字符串内的字符将打印制表符（一个制表符与打印四个空格相同）。例如：

>>>

>>> s = "Name\tAge\tMarks"

>>> s

\'Name\tAge\t\\Marks\'

>>> print(s)

Name Age Marks

>>>

同样\n，字符串内的字符会打印换行符。换行符不显示在屏幕上，而是使光标从下一行的开头开始打印后续字符。例如：

>>>

>>> s2 = \'One\nTwo\nThree\'

>>> s2

\'One\nTwo\nThree\'

>>> print(s2)

One

Two

Three

>>>

您还可以使用（\\'）和（\"）转义序列在字符串中打印单引号或双引号。例如：

>>>

>>> print(\'I\\'m learning python\')

I\'m learning python

>>>

>>> print("John says \"Hello there !\"")

John says "Hello there !"

>>>

当我们使用转义序列打印单引号或双引号时，字符串是否被包裹在单引号或双引号内并不重要。

类似于打印单个反斜杠字符（\）使用（\\）转义序列。

>>>

>>> s3 = \'C:\\Users\\Q\'

>>> s3

\'C:\\Users\\Q\'

>>> print(s3)

C:\Users\Q

>>>

字符串连接＃

字符串连接意味着将一个或多个字符串连接在一起。要在Python中连接字符串，我们使用+运算符。

>>>

>>> s1 = "This is " + "one complete string"

>>> print(s1)

This is one complete string

>>>

>>> s2 = "One " + "really really " + "long string"

>>> print(s2)

One really really long string

>>>

请注意，+运算符与两个数字一起使用时会执行数学加法。但是，当与字符串一起使用时，它们将它们连接起来。

>>>

>>> 98+57 # when used with numbers + operators adds them

155

>>>

如果其中一个操作数不是字符串会发生什么？例如：

>>>

>>> s = "Python" + 101

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

TypeError: Can\'t convert \'int\' object to str implicitly

>>>

这里磨损是试图连接字符串"Python"和数字101，但是Python报告了以下错误：

TypeError: Can\'t convert \'int\' object to str implicitly

由于Python是一种强类型语言，它不能将一种类型的数据自动转换为完全不同的类型。

那么解决方案是什么？

解决方法是使用str()函数将整数转换为字符串，如下所示：

>>>

>>> s = str(100)

>>> s

\'100\'

>>> type(s)

>>>

>>> s = "Python" + str(101)

>>> s

\'Python101\'

>>>

字符串重复操作符（*）＃

就像数字一样，我们也可以使用*字符串操作符。当与字符串一起使用时，*运算符会重复该字符串n的次数。它的一般格式是：

string * n

哪里n是一些类型int。

>>>

>>> s = "www " * 5 # repeat "www " 5 times

>>> s

\'www www www www www \'

>>>

>>> print("We have got some", "spam" * 5)

We have got some spamspamspamspamspam

>>>

请注意5 * "www "并"www " * 5产生相同的结果。

在n必须int。否则，你会得到一个错误。例如：

>>> "www" * "e" # n is a string

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

TypeError: can\'t multiply sequence by non-int of type \'str\'

>>>

>>> "www" * 1.5 # n is a float

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

TypeError: can\'t multiply sequence by non-int of type \'float\'

>>>

请注意，错误消息告诉我们一个字符串不能与非int类型相乘。

会员运营商 - 在和不在＃

该in或not in运营商用于检查某个字符串在另一字符串的存在。例如：

>>>

>>> s1 = "object oriented"

>>>

>>> "ted" in s1 # Does "ted" exists in s1 ?

True

>>>

>>> "eject" in s1 # Does "eject" exists in s1 ?

False

>>>

>>> "orion" not in s1 # Doesn\'t "orion" exists in s1 ?

True

>>>

>>> "en" not in s1 # Doesn\'t "en" exists in s1 ?

False

>>>

访问字符串中的单个字符＃

在Python中，字符串中的字符按顺序存储。我们可以使用索引访问字符串中的单个字符。索引指字符在字符串中的位置。在Python中，字符串被0索引，这意味着第一个字符在索引处0，第二个字符在索引处1等等。最后一个字符的索引位置比字符串的长度小1。

要访问字符串中的单个字符，我们输入变量的名称，然后输入方括号内的字符的索引号[]。

>>>

>>> s1 = "hello"

>>>

>>> s1[0] # get the first character

\'h\'

>>> s1[1] # get the second character

\'e\'

>>> s1[2] # get the third character

\'l\'

>>> s1[3] # get the fourth character

\'l\'

>>> s1[4] # get the fifth character

\'o\'

>>>

字符串的最后一个有效索引s1是4，如果您尝试访问超出最后一个有效索引的字符，您将获得IndexError如下所示的字符：

>>>

>>> s1[5] # get the sixth character

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

IndexError: string index out of range

>>>

我们可以使用该len()函数来计算字符串，然后1从中减去以获取最后一个字符的索引位置，而不是手动计算字符串中最后一个字符的索引位置。

>>>

>>> quote = "The best is the enemy of the good"

>>>

>>> quote[len(quote)-1]

\'d\'

>>>

我们也可以使用负指数。负索引允许我们从字符串的末尾访问字符。负索引从-1第一个字符开始，所以最后一个字符的索引位置是-1，第二个最后一个字符是-2，依此类推。

>>>

>>> s = "markdown"

>>>

>>> s[-1] # get the last character

\'n\'

>>>

>>> s[-2] # get the second last character

\'w\'

>>>

>>> s[-8] # get the first character

\'m\'

>>>

>>> s[-len(s)] # get the first character

\'m\'

>>>

如果负指数小于最后一个有效指标（-8），IndexError则会发生如下情况：

>>>

>>> s[-9]

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

IndexError: string index out of range

>>>

切片字符串＃

字符串切片允许我们从字符串中获取一段字符。为了得到一段字符串，我们使用切片运算符（[start_index:end_index]）。它的语法是：

str_name[start_index:end_index]

str_name[start_index:end_index]返回字符串的开始从指数片start_index的end_index。该字符end_index将不会包含在切片中。考虑下面的例子：

>>>

>>> s = "markdown"

>>>

>>> s[0:3] # get a slice of string starting from index 0 to 3, not including the character at index 3

\'mar\'

>>>

>>> s[2:5] # get a slice of string starting from index 2 to 5, not including the character at index 5

\'rkd\'

>>>

如果end_index大于字符串的长度，则切片运算符将返回从字符串开始start_index到字符串结尾的一段字符串。

>>>

>>> s[2:len(s)+200]

\'rkdown\'

>>>

该start_index和end_index是可选的。如果start_index没有指定，则切片从字符串的开始处开始，如果end_index未指定，则切换到字符串的末尾。例如：

>>>

>>> s[:4] # start slicing from the beginning

\'mark\'

>>>

在上面的表达式中，切片从字符串的开始处开始，所以上面的表达式与之相同s[0:4]。

>>>

>>> s[5:]

\'own\'

>>>

在这种情况下，end_index结果会被忽略，切片会继续到字符串的末尾，所以与之s[5:]相同s[5:len(s)]。

>>>

>>> s[:]

\'markdown\'

>>>

这里我们省略start_index以及end_index，从而切片将从头开始，并继续到字符串的结尾。换句话说，s[:]是一样的s[0:len(s)]

我们也可以在字符串切片中使用负指数。

因此，s[1:-1]将返回开始从指数片1来-1，不包括索引字符-1。

>>>

>>> s[1:-1]

\'arkdow\'

>>>

Python中的所有东西都是对象＃

在Python中，所有数据都是对象。它意味着一个数字，一个字符串，其他类型的数据实际上是一个对象。要确定我们使用type()函数的对象的类型。

但什么是对象？

类和对象 - 第一次看＃

在我们了解对象之前，我们必须先了解类。一个类只是一个定义数据和方法的模板。在类中定义的函数称为方法。

class our_class

data

methods

当我们定义一个新类时，我们基本上会创建一个新的数据类型。要使用我们的新类或数据类型，我们必须创建该类的对象。请注意，定义一个类不会占用内存中的任何空间。内存仅在我们基于该类创建对象时分配。

根据这个新获得的知识，让我们看看int为变量赋值时实际发生了什么。

>>> num = 100

在上面的语句中，我们给100变量赋了一个值num。在面向对象的术语中，我们刚刚创建了一个对象。要了解有关对象的类或类型的更多信息，请使用以下type()方法：

>>>

>>> type(num)

>>>

<class \'int\'>表示num变量是类的对象int。同样，每个字符串float都是类str和对象float。

内置类或类型，如int，float，str; 定义许多有用的方法。要调用这些方法，我们使用以下语法：

object.method_name()

这里是一个例子：

这个str类提供了类似的方法upper()，lower()并且在将它们分别转换为大写和小写之后返回一个字符串。

>>>

>>> s1 = "A String"

>>>

>>> s2 = s.lower()

>>> s2

\'a string\'

>>>

>>> s3 = s.upper()

>>> s3

\'A STRING\'

>>>

>>> s3

>>>

这些方法不会改变原始对象（s1）的值。这就是为什么after调用lower()和upper()变量s1仍然指向"A String"字符串对象。

>>>

>>> s1

\'A String\'

>>>

要知道对象的内存地址，我们可以使用id()如下函数：

>>>

>>> id(s1)

15601373811

>>>

需要注意的是15601373811是的地址\'A String\'字符串对象没有地址s1变量。对象的内存地址在执行程序期间不会改变。但是，每次运行程序时都可能会发生变化。如果两个对象相同，那么它们将具有相同的ID（或地址）。

ASCII字符＃

在计算机中，每件事物都以0和1的系列存储。存储数字非常简单，只需将它们转换为二进制文件即可完成。

但是如何将字符存储在内存中？

计算机不能直接存储字符串，如\'a\'，\'b\'，\'1\'，\'$\'等在记忆中。相反，他们存储的是代表角色的数字代码。字符及其数字代码的映射称为ASCII（美国信息交换标准代码）字符集。ASCII字符集有128个字符。

除了美式键盘中的字符外，ASCII集还定义了一些控制字符。控制字符用于发出命令，它们是不可打印的字符。

控制字符的一个例子是Ctrl + D，它通常用于终止shell窗口。ASCII表中的这个字符用EOT（传输结束）表示，并且ASCII值为4。

下表显示了ASCII字符集中的所有128个字符。

这里有几件事要注意：

从所有的大写字母A来Z从具有ASCII值65来90。
从所有的小写字母\'a\'，以\'z\'从具有ASCII值97来122。
当我们在字符串内使用数字（0- 9）时，它们使用来自48to的ASCII值表示57。

ord（）和chr（）函数＃

该ord()函数返回一个字符的ASCII值，该chr()函数返回由ASCII值表示的字符。

ord（）函数＃

>>>

>>> ord("a") # print the ASCII value of character a

>>>

>>> ord("5") # print the ASCII value of character 5

>>>

chr（）函数＃

>>>

>>> chr(97) # print the character represented by ASCII value 97

\'a\'

>>>

>>> chr(53) # print the character represented by ASCII value 53

\'5\'

>>>

在print（）函数中抑制换行符＃

默认情况下，该print()函数打印它的参数后跟一个换行符（\n）。例如：

python101 /章-07 / newline_at_the_end.py

print("first line")

print("second line")

输出：

first line

second line

请注意，字符串"second line"打印在下一行的开头，这是因为\n第一次print()调用打印的换行符（）会导致输出从下一行开始。

我们可以print()通过传递一个特殊的参数来改变函数的行为end。假设我们想$在输出结束处打印字符而不是换行符（\n）。要做到这一点，调用print()函数如下：

python101 /章-07 / dollor_at_the_end.py

print("first string", end="$")

print("second string", end="$")

输出：

first string$second string$

注意\'$\'两个字符串末尾的字符。由于第一条语句不在输出结尾处显示换行符，因此第二条语句的输出print()在同一行上开始。

如果您不想在输出传递end=""到该print()函数的末尾打印任何内容，如下所示：

python101 /章-07 / nothing_at_end.py

print("first", end="")

print("second", end="")

print("third")

输出：

firstsecondthird

在这种情况下，前两个语句""在输出结尾处打印一个空字符串（），但最后一个语句打印"third"后跟一个换行符（\'\n\'）。

在print（）函数中指定分隔符＃

我们已经在课堂上讨论了数据类型和变量在Python中，当我们将多个参数传递给print()函数时，它们被打印到由空格分隔的控制台。

>>>

>>> print("first", "second", "third")

first second third

>>>

要覆盖这种行为，我们使用另一个称为sepshort的特殊参数作为分隔符假设我们想要通过分隔每个项目#。为此，请print()按如下所示调用函数：

>>>

>>> print("first", "second", "third", sep="#")

first#second#third

>>>

字符串比较＃

就像数字一样，我们也可以使用关系运算符比较字符串。但是，与数字不同，字符串比较涉及更多。Python中的字符串使用相应字符的ASCII值进行比较。比较从比较两个字符串的第一个字符开始。如果它们不同，则对相应字符的ASCII值进行比较以确定比较结果。另一方面，如果它们相等，则下两个字符进行比较。这个过程一直持续到任何一个字符串被耗尽。如果一个短字符串出现在另一个长字符串的开头，那么短字符串就会更小。在技术术语中，这种类型的比较称为字典比较。

我们举一些例子：

例1：

>>>

>>> "linker" > "linquish"

False

>>>

以下是评估上述表达式的步骤：

步骤1："l"从"link"与比较"l"从"linq"。由于它们相同，接下来的两个字符进行比较。

步骤2："i"从"link"与比较"i"从"linq"。再次他们是平等的，接下来的两个字符进行比较。

步骤3："n"从"link"与比较"n"从"linq"。再次他们是平等的，接下来的两个字符进行比较。

步骤4："k"从"link"与比较"q"从"linq"。比较在此步骤停止，因为相应的字符不相同。kis 107和is 的ASCII值q是113，那意味着"k"小于"q"。所以弦"linker"比小"linquish"。因此表达"linker" > "linquish"是错误的。

例2：

>>>

>>> "qwerty" > "abc"

True

>>>

"q"从"qwerty"与比较"a"从"abc"。此时，比较停止，因为相应的字符不相同。由于"q"is 113和is 的ASCII值"a"是97，所以"q"大于"a"。所以字符串"qwerty"大于"abc"。

例3：

>>>

>>> "ab" > "abc"

False

>>>

这里短字符串"ab"出现在另一个长字符串的开头"abc"。因此"ab"是较小的一个。

更多的例子：

>>>

>>> "tree" == "tree"

True

>>>

>>> "pass" != "password"

True

>>>

>>> "@@@" <= "123"

False

>>>

>>> "" <= "123"

True

>>>

字符串比较是编程中的常见操作。字符串比较的一个实际用法是按照升序或降序对字符串进行排序。

字符串是不可变的＃

字符串对象是不可变的。这意味着我们不能在创建字符串对象后更改其内容。考虑下面的例子：

>>>

>>> s = "hello"

>>>

>>> id(s)

35145912

>>>

这里我们创建了一个新的字符串对象，然后我们使用id()函数来知道我们的字符串对象的地址。

让我们看看如果我们试图s通过添加" world"到现有字符串对象的末尾来修改现有的字符串对象会发生什么。

>>>

>>> s += " world"

>>> s

\'hello world\'

>>>

>>> id(s)

35150448

>>>

注意变量s现在指向一个全新的地址，这是因为每次我们修改一个字符串对象时，我们都会在这个过程中创建新的字符串对象。这证明了字符串对象是不可变的。

表单的形式variable[index]就像变量一样处理。因此，它们也可以出现在赋值运算符的左侧。例如：

>>>

>>> s[0] = \'y\'

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

TypeError: \'str\' object does not support item assignment

>>>

在这里，我们试图0通过为它指定一个新的字符串来更新索引处的元素。操作失败，因为字符串对象是不可变的。如果字符串是可变的，上述操作将会成功。

格式化字符串使用format（）函数＃

就像数字一样，我们也可以使用format()函数来格式化字符串。要格式化字符串，我们使用类型代码s和指定的宽度，例如：

>>>

>>> print(format("Python", "10s"))

Python

>>>

与数字不同，字符串默认是左对齐的。这意味着当宽度大于值的长度时，该值是打印左对齐后面的空格而不是前导空格。

如果字符串的长度大于指定的宽度，则会自动增加宽度以匹配字符串的长度。

>>>

>>> print(format("Python", "4s"))

Python

>>>

要向右对齐字符串，请>按如下所示使用符号：

>>>

>>> print(format("Python", ">10s"))

Python

>>>

该声明print(format("Python", "<10s"))与print(format("Python", "10s"))因为字符串默认情况下打印左对齐相同。