Comment résoudre les problèmes de conversion de caractères, de fractionnement de chaînes et de fusion de chaînes dans les chaînes Python

1. Conversion de caractères de chaînes

1.1. Concept de conversion de caractères

Le remplacement de chaîne mentionné précédemment consiste à remplacer une sous-chaîne dans la chaîne par une nouvelle sous-chaîne si vous souhaitez convertir certains caractères dans un. chaîne, c'est-à-dire remplacer un seul caractère dans une chaîne, vous pouvez appeler les méthodes maketrans et traduire.

Appelez d'abord la méthode maketrans pour créer une table de conversion, déclarez dans la table de conversion en quels caractères convertir ces caractères, puis transmettez la table de conversion créée en tant que paramètre à la méthode de traduction pour implémenter la conversion de caractères.

La syntaxe de la méthode maketrans pour créer une table de conversion :

str.maketrans('转换的字符', '转换后的字符','删除的字符')

La méthode maketrans peut passer trois paramètres :

• Le premier paramètre est utilisé pour spécifier les caractères à convertir, alors si plusieurs caractères sont spécifiés, alors. les caractères convertis Vous devez également en spécifier plusieurs, et les nombres doivent être les mêmes. Le premier caractère à convertir sera converti en premier caractère du deuxième paramètre, qui sera expliqué dans le cas.

• Le deuxième paramètre est utilisé pour spécifier les caractères convertis.

• Le troisième paramètre est utilisé pour spécifier les caractères à supprimer.

Après avoir défini une table de conversion, vous pouvez utiliser print pour imprimer le contenu de la table de conversion. A ce moment, un dictionnaire est renvoyé. Chaque clé:valeur du dictionnaire est la valeur ordinale correspondant au caractère. La méthode

translate passe la table de conversion en tant que paramètre, puis l'appelle avec la chaîne définie pour finalement réaliser la conversion des caractères.

1.2. Cas d'application de conversion de caractères

1) Création d'une table de conversion

Lors de la définition de la table de conversion, si plusieurs caractères à convertir sont spécifiés, le nombre de caractères convertis doit être le même que le nombre de caractères convertis. caractères , à ce moment le premier paramètre et le deuxième paramètre seront convertis de manière croisée, le code est le suivant.

contable = str.maketrans('agx', '789')
print(contable)

'''
代码解释：
    str.maketrans('agx', '789')定义了一个转换表，其中字符a转换成字符7，字符g转换成字符8，字符x转换成字符9
    当使用print函数打印定义的转换表时，返回的是一个字典，key是被转换的字符，value是转换后的字符，并且返回的是字符的ordinal value值
    返回结果：{97: 55, 103: 56, 120: 57}
        {97是字符a: 55是字符7, 103是字符g: 56是字符8, 120是字符x: 57是字符9}
'''

Vous pouvez utiliser la fonction print pour imprimer la table de conversion. Le résultat renvoyé est un dictionnaire. La valeur dans le dictionnaire est la valeur ordinale du caractère correspondant, vous pouvez clairement voir en quel caractère sera converti. quel caractère, comme indiqué ci-dessous. 97 est le caractère a, 55 est le caractère 7, et les caractères correspondant à 97 seront convertis en caractères correspondant à 55.

En plus de déclarer directement les caractères convertis et les valeurs originales des caractères convertis sous forme de chaînes, vous pouvez également utiliser la méthode dictionnaire pour déclarer la conversion et les caractères convertis, car le résultat renvoyé par le La table de conversion est un dictionnaire, mais la méthode la plus courante consiste à déclarer directement les caractères à convertir dans la table de conversion.

#使用字典的形式，在字典中声明转换的字符、被转换字符的原始值
contable = str.maketrans({'a': '7', 'g': '8', 'x': '9'})
print(contable)
'''
	此时使用print打印转换表时，就会发现转换后的字符会以原始值的形式记录在字典中，被转换的字符还是以ordinal value值表示
'''
#输出结果：{97: '7', 103: '8', 120: '9'}

#还是使用字典的行驶，在字典中声明被转换字符、转换字符的ordinal value值
contable = str.maketrans({97: 55, 103: 56, 120: 57})
print(contable)
'''
	这种方法需要实现使用ord函数获取被转换字符、转换字符的ordinal value值，然后在字典中直接声明字符的ordinal value值
'''
#输出结果：{97: 55, 103: 56, 120: 57}

2) Conversion de caractères

#首先定义一个转换表，这个转换表可以被任意字符串调用使用
contable = str.maketrans('agx', '789')

#定义一个字符串
mystr = 'jiangxluplader'

#使用translate方法将转换表以参数的形式传入，然后由字符串调用这个方法实现字符的转换
print(mystr.translate(contable))

#输出结果：ji7n89lupl7der

a constaté que tous les caractères a de la chaîne étaient convertis en 7, tous les caractères g étaient convertis en 8 et tous les caractères x étaient convertis en 9.

3) Lorsque la méthode maketrans définit la table de conversion, vous pouvez également spécifier les caractères à supprimer, comme par exemple supprimer les caractères u, p

contable = str.maketrans('agx', '789', 'up')
mystr = 'jiangxluplader'
print(mystr.translate(contable))

'''
	maketrans方法创建转换表时，第三个参数是指定删除的字符
'''

#输出结果：ji7n89ll7der

4) Lorsque la méthode maketrans définit la table de conversion, vous pouvez également ne pas supprimer les caractères Conversion, supprimer uniquement certains caractères, par exemple supprimer uniquement les caractères u, p .

2. Fractionnement de chaîne

2.1. Le concept de fractionnement de chaîne

Le soi-disant fractionnement de chaîne fait référence à la division de la chaîne en N morceaux selon le délimiteur spécifié, par exemple pour la chaîne "aaa bbb", le délimiteur par défaut est un espace. Selon le délimiteur, cette chaîne peut être divisée en "aaa" et "bbb". Il existe deux façons de diviser une chaîne :

1) Appelez la méthode split ou rsplit pour diviser une chaîne

La méthode split consiste à diviser la chaîne en commençant par le côté gauche de la chaîne et en commençant par l'avant à l'arrière. La méthode

rsplit consiste à diviser la ficelle en commençant par le côté droit de la ficelle et en commençant de l'arrière vers l'avant.
Les méthodes split et rsplit diviseront tous les endroits où le délimiteur apparaît dans la chaîne en fonction du délimiteur.

• Le délimiteur par défaut est une chaîne d'espace. Si le nombre maximum de divisions n'est pas spécifié par ces deux méthodes, il n'y aura aucune différence dans le contenu de sortie et la valeur de retour des deux méthodes est une liste.

  当字符串中没有指定的分隔符时，这两个方法都会返回字符串本身，但是也会将字符串本身放在列表中。

  2）调用方法partition或者rpartition劈分字符串

  partition和rpartition这两个方法在调用的时候必须指定分隔符，然后对字符串进行劈分，这两个方法对字符串劈分后会返回一个元组。

  • partition方法是左劈分，从左往右找到分隔符第一次出现的位置，然后开始劈分字符串，始终劈分成三个元素，第一个元素是分隔符左侧的部分，第二个元素是分隔符，第三个元素是分隔符后面的部分。

  • rpartition方法是右劈分，从右往左找到分隔符第一次出现的位置，或者从左往右找到分隔符最后一次出现的位置，然后开始劈分字符串，始终劈分成三个元素，第一个元素是分隔符左侧的部分，第二个元素是分隔符，第三个元素是分隔符后面的部分。

  partition方法和rpartition只会将字符串中第一次出现分隔符的位置，进行劈分，一分为三，这就是与split方法的最大区别

  partition方法和rpartition两个方法只是开始劈分的位置处不同，然后将字符串劈分为三个元素：

  • 分隔符前面的部分

  • 分隔符

  • 分隔符后面的部分

  如果字符串中不存在指定的分隔符，两个方法都会返回字符串本身，partition方法劈分的三个元素顺序依次为：字符串本身、空字符串、空字符串，rpartition方法劈分的三个元素依次为：空字符串、空字符串、字符串本身。

  2.2.调用方法split或者rsplit劈分字符串

  1）基本的劈分案例

  #原始字符串
  mystr = "DevOps Jenkins Kubernetes"
  
  #左劈分
  print(mystr.split())
  
  #右劈分
  print(mystr.rsplit())
  
  '''
  	左劈分是从DevOps第一个空格字符串处开始劈分，右劈分是从Kubernetes最后一个空格字符串处开始劈分
  	默认的劈分字符串是空格字符串，只要遇到空格字符串，就将空格字符串左侧的字符串劈分出来。
  '''

  可以看到split和rsplit两个方法对字符串劈分后，并没有明显的区别。

  

  2）通过参数sep指定分隔符劈分字符串

  在split和rsplit方法中都可以使用sep参数指定分隔符，从而根据指定的分隔符去劈分字符串。

  mystr = "DevOps|Jenkins|Kubernetes"
  print(mystr.split(sep='|'))
  print(mystr.rsplit(sep='|'))
  
  '''
  	split(sep='|')、rsplit(sep='|')指定分隔符为“|”
  '''

  可以看到split和rsplit两个方法对字符串劈分后，并没有明显的区别。

  

  当指定的分隔符字符串不存在时，则会返回字符串本身，但是也会将字符串本身放在列表中。

  mystr = "DevOps Jenkins Kubernetes"
  print(mystr.split(sep='|'))
  print(mystr.rsplit(sep='|'))

  

  3）通过参数maxsplit指定劈分字符串的最大劈分次数

  在split和rsplit方法中都可以使用maxsplit参数指定劈分字符串的最大劈分次数，什么意思呢？原本一个字符串可以被劈分6次，但是我们只需要劈分2次就行，就可以使用maxsplit参数指定指定劈分字符串的最大劈分次数。

  当指定了最大的劈分次数时，当超过最大的劈分次数后，剩余的子串会单独作为一部分输出，此时split和rsplit两个劈分方法就会有明显的区别。

  #定义原始字符串
  mystr = "DevOps|Jenkins|Kubernetes|Python|Gitlab"
  
  '''
  	使用split方法是从左往右开始劈分，从第一个子串位置处开始劈分，分隔符为"|"，劈分次数为2，本身这个字符串可以被劈分5次，我们只劈分2次，那么DevOps、Jenkins会被劈分出来作为列表的单独元素，而剩余的子串Kubernetes|Python|Gitlab会被作为一部分放在列表的一个元素内
  '''
  print(mystr.split(sep='|', maxsplit=2))
  #输出结果：['DevOps', 'Jenkins', 'Kubernetes|Python|Gitlab']
  
  '''
  	使用rsplit方法是从右往左开始劈分，从最后一个子串处开始劈分，分隔符为"|"，劈分次数为2，本身这个字符串可以被劈分5次，我们只劈分2次，那么Gitlab、Python这两个字符串会被劈分出来作为列表的单独元素，而剩余的字符DevOps|Jenkins|Kubernetes会被作为一部分，放在列表的一个元素内
  '''
  print(mystr.rsplit(sep='|', maxsplit=2))
  #输出结果：['DevOps|Jenkins|Kubernetes', 'Python', 'Gitlab']

  当在劈分方法内指定了最大的劈分次数的参数时，split左劈分和rsplit右劈分就会有明显的区别，split方法是从前往后根据分隔符进行劈分，rsplit方法是从后往前根据分隔符进行劈分。

  

  2.3.调用方法partition或者rpartition劈分字符串

  partition方法是左劈分，从左往右找到分隔符第一次出现的位置，然后开始劈分字符串，始终劈分成三个元素，第一个元素是分隔符左侧的部分，第二个元素是分隔符，第三个元素是分隔符后面的部分。

  rpartition方法是右劈分，从右往左找到分隔符第一次出现的位置，或者从左往右找到分隔符最后一次出现的位置，然后开始劈分字符串，始终劈分成三个元素，第一个元素是分隔符左侧的部分，第二个元素是分隔符，第三个元素是分隔符后面的部分。

  这两个方法，只会根据一个分隔符进行劈分字符串，且始终劈分成三个元素，partition方法的分隔符取决于在字符串中第一次出现的分隔符，rpartition方法的分隔符取决于字符串中最后一次出现的分隔符。

  1）调用方法partition劈分字符串

  mystr = "DevOps|Jenkins|Kubernetes|Python|Gitlab"
  print(mystr.partition('|'))
  
  '''
  	partition从左往右找到第一次出现分隔字符串的位置，从这里开始劈分字符串，分隔符左侧的部分（DevOps）为第一个元素，分隔符（|）为第二个元素，分隔符右侧的部分（Jenkins|Kubernetes|Python|Gitlab）为第三个元素。
  '''
  
  #输出结果：('DevOps', '|', 'Jenkins|Kubernetes|Python|Gitlab')

  

  2）调用方法rpartition劈分字符串

  mystr = "DevOps|Jenkins|Kubernetes|Python|Gitlab"
  print(mystr.rpartition('|'))
  
  '''
  	rpartition从左往右找到最后一次出现分隔字符串的位置，分隔符左侧的部分（DevOps）为第一个元素，分隔符（|）为第二个元素，分隔符右侧的部分（Jenkins|Kubernetes|Python|Gitlab）为第三个元素。
  '''
  
  #输出结果：('DevOps|Jenkins|Kubernetes|Python', '|', 'Gitlab')

  确实和理论说明的一样，从左往右找到最后一次分隔符出现的位置，分隔符左侧的部分为元组中的第一个元素，分隔符为第二个元素，分隔符右侧的部分为元组中的第三个元素。

  

  3）当字符串中只有一个分隔符字符串且分隔符后没有任何字符时

  当字符串中只有一个分隔符字符串时，且分隔符后面没有任何字符串，此时无论是partition方法还是rpartition方法，劈分的字符串第三个元素一定为空。

  mystr = "DevOps|"
  print(mystr.partition('|'))
  print(mystr.rpartition('|'))

  第三个元素取的都是分隔符后面的部分，分隔符后面的部分什么也没有，因此就会输出空字符串。

  

  4）当字符串中不存在指定的分隔符字符串（partition方法）

  如果字符串中不存在指定的分隔符，partition方法劈分的三个元素顺序依次为：字符串本身、空字符串、空字符串。

  mystr = "DevOps|Jenkins|Kubernetes|Python|Gitlab"
  print(mystr.partition('*'))
  
  #输出结果：('DevOps|Jenkins|Kubernetes|Python|Gitlab', '', '')

  第一个元素是字符串的本身，第二个元素是空字符串，第三个元素也是空字符串。

  

  4）当字符串中不存在指定的分隔符字符串（rpartition方法）

  如果字符串中不存在指定的分隔符，rpartition方法劈分的三个元素顺序依次为：空字符串、空字符串、字符串本身。

  mystr = "DevOps|Jenkins|Kubernetes|Python|Gitlab"
  print(mystr.rpartition('*'))

  第一个元素是空字符串，第二个元素是空字符串，第三个元素是字符串的本身。

  

  3.字符串的合并

  可以调用方法join将多个字符串合并成一个字符串。语法格式如下：

  '字符串的间隔符'.join(列表|数组)
  
  字符串的间隔符可以指定，也可以不指定，指定后，每个元素字符串在合并时都会在后面添加一个分隔符。

  1）使用join方法将列表中多个字符串进行合并

  使用join方法可以将列表中的多个元素，元素也都是字符串，将这些字符串进行合并。

  print(''.join(["Python", "Go", "K8S"]))
  
  #输出结果：PythonGoK8S

  使用join方法将列表中的每个元素合并时添加一个分隔符“|”

  print('|'.join(["Python", "Go", "K8S"]))
  
  #输出结果：Python|Go|K8S

  2）使用join方法将元组中的多个字符串进行合并

  join方法也可以将元组中的元素合并。

  print('|'.join(("Python", "Go", "K8S")))
  
  #输出结果：Python|Go|K8S

  3）可以把字符串看成是字符的列表，然后使用join方法将这些字符合并成字符串

  可以把字符串看成是字符的列表，然后使用join将这些字符加上分隔符合并成新的字符串。

  print('|'.join("Python"))
  
  #输出结果：P|y|t|h|o|n

  

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!