Explication détaillée des connaissances de base sur les types de chaînes en Python

Cet article présente principalement le tutoriel d'apprentissage des connaissances de base du type String en Python, y compris le caractère d'échappement et la concaténation de chaînes ainsi que la chaîne d'origine Pour l'explication des connaissances de base, les amis qui en ont besoin peuvent se référer à

S'il existe de nombreuses méthodes de classification intermédiaire pour la classification des langues naturelles, comme l'anglais, le français, le chinois, etc., cette méthode de classification est la plus courante. En linguistique, il existe également des moyens de classer les langues, comme les familles de langues, etc. Je propose ici une méthode de classification. Cette méthode de classification n'a pas encore été largement reconnue par les larges masses populaires et les chercheurs. Cependant, je pense que l'adage « la vérité est entre les mains de quelques personnes » peut au moins être utilisé. ici pour m'expliquer. Soyez courageux.

Ma façon de le diviser : l'une consiste à assembler deux éléments de la langue (comme deux mots) pour créer un nouvel élément (comme un nouveau mot) ; l'autre consiste à assembler deux éléments ensemble ; , vous obtenez simplement une juxtaposition de ces deux éléments. Par exemple, « bonnes » et « personnes », les deux éléments assemblés sont « bonnes personnes », et l'épissage de 3 et 5 (c'est-à-dire la somme des entiers) ensemble est 8. Si vous pensez qu’il s’agit de 35 ans, alors il appartient à la deuxième catégorie.

Résumé ma division :

L'une est : △ □ = ○
L'autre est : △ □ = △ □
Dans notre langue, indissociable des deux catégories ci-dessus, soit la première catégorie ou la deuxième catégorie.

Quel génie. Veuillez applaudir.

String
Quand je me sentais complaisant, je l'ai recherché sur Google et j'ai réalisé que je n'étais pas si intelligent. L'entrée Wikipédia pour les chaînes disait ceci :

String (. String) est une séquence finie de zéro ou plusieurs caractères. Généralement enregistré comme s=a[1]a[2]...a[n].
Voyez à quel point Wikipédia est génial. Il a donné à une situation que j'ai imaginé un nom vivant, appelé chaîne, qui est essentiellement une chaîne de caractères.

Selon cette définition, "Hello, World", qui a déjà permis à un programmeur de se sentir bien à deux reprises, est une chaîne. En d’autres termes, qu’il soit en anglais, en chinois ou dans une autre langue, le texte écrit peut être traité comme une chaîne. Bien entendu, les symboles spéciaux qu’il contient peuvent également être utilisés comme une chaîne, comme des espaces, etc.

À proprement parler, une chaîne en Python est un type d'objet. Ce type est représenté par str, généralement entouré de guillemets simples '' ou de guillemets doubles "".

Les chaînes, comme les nombres mentionnés précédemment, sont à la fois des types d'objets ou des valeurs. Bien entendu, les méthodes d’expression sont encore différentes.

"I love Python." 'I love Python.' 'I LOVE PYTHON.' 'I LOVE PYTHON.'

Comme vous pouvez le constater sur ces deux exemples, que vous utilisiez des guillemets simples ou des guillemets doubles, le résultat est le même .

>>> 250
250
>>> type(250)
<type &#39;int&#39;>

>>> "250"
&#39;250&#39;
>>> type("250")
<type &#39;str&#39;>

Regardez attentivement la différence ci-dessus. Elle est également de 250. L'un n'est pas placé entre guillemets et l'autre l'est. placé entre guillemets. , utilisez la fonction type() pour vérifier et trouver qu'il s'agit en fait de deux types d'objets différents, le premier est de type int et le second est de type str, c'est-à-dire de type chaîne. Par conséquent, sachez que tous les nombres ne sont pas des entiers (ou des flottants). Vous devez voir où ils se trouvent. S'ils sont entre guillemets, il s'agit d'une chaîne. Si vous ne savez pas de quel type il s'agit, laissez type() vous aider à le comprendre.

Pratirons-nous sur les cordes.

>>> print "good good study, day day up"
good good study, day day up
>>> print "----good---study---day----up"
----good---study---day----up

Après l'impression, tout ce qui est imprimé est une chaîne. Notez qu'il est entre guillemets doubles et que les guillemets ne font pas partie de la chaîne. Cela indique à l'ordinateur qu'il est enveloppé dans une chaîne.

Les lecteurs réfléchis ont dû trouver quelque chose qui ne va pas avec la phrase ci-dessus. Que dois-je faire si je veux traiter la phrase suivante comme une chaîne ?

Comment vous appelez-vous ?
Cette question est très bonne car il y a un simple guillemet dans cette phrase Si vous la tapez directement dans le mode interactif comme ci-dessus, elle ressemblera à cela. ceci :

>>> 'What's your name?'
File "<stdin>", line 1
 &#39;What&#39;s your name?&#39;
  ^
SyntaxError: invalid syntax

Une invite SyntaxError (erreur de syntaxe) apparaît, qui nous indique qu'il y a une erreur ici et le type d'erreur Il s'agit de SyntaxError, suivi de l'explication de cette erreur "syntaxe invalide" (syntaxe invalide). Portez une attention particulière au fait qu'il y a un symbole ^ au-dessus du message d'erreur, suivi d'un guillemet simple, vous pouvez deviner que cela nous indique probablement qu'il peut y avoir une erreur ici.

在 python 中，这一点是非常友好的，如果语句存在错误，就会将错误输出来，供程序员改正参考。当然，错误来源有时候比较复杂，需要根据经验和知识进行修改。还有一种修改错误的好办法，就是讲错误提示放到 google 中搜索。
上面那个值的错误原因是什么呢？仔细观察，发现那句话中事实上有三个单引号，本来一对单引号之间包裹的是一个字符串，现在出现了三个（一对半）单引号，computer 姑娘迷茫了，她不知道单引号包裹的到底是谁。于是报错。

解决方法一：双引号包裹单引号

>>> "What's your name?"
"What's your name?"

用双引号来包裹，双引号里面允许出现单引号。其实，反过来，单引号里面也可以包裹双引号。这个可以笼统地成为二者的嵌套。

解决方法二：使用转义符

所谓转义，就是让某个符号不在表示某个含义，而是表示另外一个含义。转义符的作用就是它能够转变符号的含义。在 Python 中，用 \ 作为转义符（其实很多语言，只要有转义符的，都是用这个符号）。

>>> 'What\'s your name?'
"What's your name?"

是不是看到转义符 \ 的作用了。

本来单引号表示包括字符串，它不是字符串一部分，但是如果前面有转义符，那么它就失去了原来的含义，转化为字符串的一部分，相当于一个特殊字符了。

变量和字符串
前面讲过变量无类型，对象有类型了，比如在数字中:

>>> a = 5
>>> a
5

其本质含义是变量 a 相当于一个标签，贴在了对象 5 上面。并且我们把这个语句叫做赋值语句。

同样，在对字符串类型的对象，也是这样，能够通过赋值语句，将对象与某个标签（变量）关联起来。

>>> b = "hello,world"
>>> b
'hello,world'
>>> print b
hello,world

还记得我们曾经用过一个 type 命令吗？现在它还有用，就是检验一个变量，到底跟什么类型联系着，是字符串还是数字？

>>> type(a)
<type &#39;int&#39;>
>>> type(b)
<type &#39;str&#39;>

有时候，你会听到一种说法：把a称之为数字型变量，把 b 叫做字符（串）型变量。这种说法，在某些语言中是成立的。某些语言，需要提前声明变量，然后变量就成为了一个筐，将值装到这个筐里面。但是，Python 不是这样的。要注意区别。

拼接字符串
还记得我在本节开篇提出的那个伟大发现吗？就是将两个东西拼接起来。

对数字，如果拼接，就是对两个数字求和。如：3+5，就计算出为 8。那么对字符串都能进行什么样的操作呢？试试吧：

>>> "Py" + "thon"
'Python'

跟我那个不为大多数人认可的发现是一样的，你还不认可吗？两个字符串相加，就相当于把两个字符串连接起来。(别的运算就别尝试了，没什么意义，肯定报错，不信就试试）

>>> "Py" - "thon"  # 这么做的人，是脑袋进水泥了吧？

Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for -: &#39;str&#39; and &#39;str&#39;

用 + 号实现连接，的确比较简单，不过，有时候你会遇到这样的问题：

>>> a = 1989
>>> b = "free"
>>> print b+a

Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
TypeError: cannot concatenate &#39;str&#39; and &#39;int&#39; objects

这里引入了一个指令：print，意思就是打印后面的字符串（或者指向字符串的变量），上面是 Python2 中的使用方式，在 Python3 中，它变成了一个函数。应该用 print(b+a)的样式了。
报错了，其错误原因已经打印出来了（一定要注意看打印出来的信息）：cannot concatenate 'str' and 'int' objects。原来 a 对应的对象是一个 int 类型的，不能将它和 str 对象连接起来。怎么办？

原来，用 + 拼接起来的两个对象，必须是同一种类型的。如果两个都是数字，毫无疑问是正确的，就是求和；如果都是字符串，那么就得到一个新的字符串。

修改上面的错误，可以通过以下方法：

>>> print b + `a`  
free1989

注意，\ 是反引号，不是单引号，就是键盘中通常在数字1左边的那个，在英文半角状态下输入的符号。这种方法，在编程实践中比较少应用，特别是在 Python3 中，已经把这种方式弃绝了。我想原因就是这个符号太容易和单引号混淆了。在编程中，也不容易看出来，可读性太差。

常言道：“困难只有一个，解决困难的方法不止一种”，既然反引号可读性不好，在编程实践中就尽量不要使用。于是乎就有了下面的方法，这是被广泛采用的。不但简单，更主要是直白，一看就懂什么意思了。

>>> print b + str(a) 
free1989

用 str(a)实现将整数对象转换为字符串对象。虽然 str 是一种对象类型，但是它也能够实现对象类型的转换，这就起到了一个函数的作用。其实前面已经讲过的 int 也有类似的作用。比如：

>>> a = "250"
>>> type(a)
<type &#39;str&#39;>
>>> b = int(a)
>>> b
250
>>> type(b)
<type &#39;int&#39;>

提醒列位，如果你对 int 和 str 比较好奇，可以在交互模式中，使用 help(int)，help(str)查阅相关的更多资料。

还有第三种：

>>> print b + repr(a) #repr(a)与上面的类似
free1989

这里 repr()是一个函数，其实就是反引号的替代品，它能够把结果字符串转化为合法的 python 表达式。

可能看官看到这个，就要问它们三者之间的区别了。首先明确，repr()和 \ 是一致的，就不用区别了。接下来需要区别的就是 repr()和 str，一个最简单的区别，repr 是函数，str 是跟 int 一样，一种对象类型。

Python 转义字符
在字符串中，有时需要输入一些特殊的符号，但是，某些符号不能直接输出，就需要用转义符。所谓转义，就是不采用符号本来的含义，而采用另外一含义了。下面表格中列出常用的转义符：

转义字符	描述
\	(在行尾时) 续行符
\	反斜杠符号
\'	单引号
\"	双引号
\a	响铃
\b	退格(Backspace)
\e	转义
\000	空
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车
\f	换页
\oyy	八进制数，yy 代表的字符，例如：\o12 代表换行
\xyy	十六进制数，yy 代表的字符，例如：\x0a 代表换行
\other	其它的字符以普通格式输出

以上所有转义符，都可以通过交互模式下 print 来测试一下，感受实际上是什么样子的。例如：

>>> print "hello.I am qiwsir.\     # 这里换行，下一行接续
... My website is 'http://qiwsir.github.io'."
hello.I am qiwsir.My website is 'http://qiwsir.github.io'.

>>> print "you can connect me by qq\\weibo\\gmail" #\\ 是为了要后面那个 \
you can connect me by qq\weibo\gmail

raw_input 和 print
分别在交互模式下，将这个两个函数操练一下。

>>> raw_input("input your name:")
input your name:python
'python'

输入名字之后，就返回了输入的内容。用一个变量可以获得这个返回值。

>>> name = raw_input("input your name:")
input your name:python
>>> name
'python'
>>> type(name)
<type &#39;str&#39;>

而且，返回的结果是 str 类型。如果输入的是数字呢？

>>> age = raw_input("How old are you?")
How old are you?10
>>> age
'10'
>>> type(age)
<type &#39;str&#39;>

返回的结果，仍然是 str 类型。

再试试 print()，看前面对它的说明，是比较复杂的。没关系，我们从简单的开始。在交互模式下操作：

>>> print("hello, world")
hello, world
>>> a = "python"
>>> b = "good"
>>> print a
python
>>> print a,b
python good

比较简单吧。当然，这是没有搞太复杂了。

特别要提醒的是，print()默认是以 \n 结尾的，所以，会看到每个输出语句之后，输出内容后面自动带上了 \n，于是就换行了。

有了以上两个准备，接下来就可以写一个能够“对话”的小程序了。

#!/usr/bin/env python
# coding=utf-8

name = raw_input("What is your name?")
age = raw_input("How old are you?")

print "Your name is:", name
print "You are " + age + " years old."

after_ten = int(age) + 10
print "You will be " + str(after_ten) + " years old after ten years."

对这段小程序中，有几点说明

前面演示了 print()的使用，除了打印一个字符串之外，还可以打印字符串拼接结果。

print "You are " + age + " years old."

注意，那个变量 age 必须是字符串，如最后的那个语句中：

print "You will be " + str(after_ten) + " years old after ten years."

这句话里面，有一个类型转化，将原本是整数型 after_ten 转化为了 str 类型。否则，就包括，不信，你可以试试。

同样注意，在 after_ten = int(age) + 10 中，因为通过 raw_input 得到的是 str 类型，当 age 和 10 求和的时候，需要先用 int()函数进行类型转化，才能和后面的整数 10 相加。

这个小程序，是有点综合的，基本上把已经学到的东西综合运用了一次。请看官调试一下，如果没有通过，仔细看报错信息，你能够从中获得修改方向的信息。

原始字符串
所谓原始字符串，就是指字符串里面的每个字符都是原始含义，比如反斜杠，不会被看做转义符。如果在一般字符串中，比如

>>> print "I like \npython"
I like 
python

这里的反斜杠就不是“反斜杠”的原始符号含义，而是和后面的 n 一起表示换行（转义了）。当然，这似乎没有什么太大影响，但有的时候，可能会出现问题，比如打印 DOS 路径（DOS，有没有搞错，现在还有人用吗？）

>>> dos = "c:\news"
>>> dos
'c:\news'  # 这里貌似没有什么问题
>>> print dos # 当用 print 来打印这个字符串的时候，就出问题了。
c:
ews

如何避免？用前面讲过的转义符可以解决：

>>> dos = "c:\\news"
>>> print dos
c:\news

此外，还有一种方法，如：

>>> dos = r"c:\news"
>>> print dos
c:\news
>>> print r"c:\news\python"
c:\news\python

状如 r"c:\news"，由 r 开头引起的字符串，就是原始字符串，在里面放任何字符都表示该字符的原始含义。

这种方法在做网站设置网站目录结构的时候非常有用。使用了原始字符串，就不需要转义了。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!