So lösen Sie die Probleme der Zeichenkonvertierung, String-Aufteilung und String-Zusammenführung in Python-Strings

1. Zeichenkonvertierung

1.1. Das Konzept der Zeichenkonvertierung

at Die zuvor erwähnte Zeichenfolgenersetzung besteht darin, eine Teilzeichenfolge in der Zeichenfolge durch eine neue Teilzeichenfolge zu ersetzen, d. h. ein einzelnes Zeichen in der Zeichenfolge zu ersetzen, was durch Aufrufen der Methode maketrans erreicht werden kann und übersetzen.

Rufen Sie zuerst die maketrans-Methode auf, um eine Konvertierungstabelle zu erstellen, deklarieren Sie in der Konvertierungstabelle, in welche Zeichen diese Zeichen konvertiert werden sollen, und übergeben Sie dann die erstellte Konvertierungstabelle als Parameter an die Translate-Methode, um die Zeichenkonvertierung zu implementieren .

Die Syntax der maketrans-Methode zum Erstellen einer Konvertierungstabelle:

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

Die maketrans-Methode kann drei Parameter übergeben:

• Der erste Parameter wird verwendet, um das zu konvertierende Zeichen anzugeben. Wenn mehrere Zeichen angegeben werden, müssen mehrere konvertierte Zeichen angegeben werden, und die Anzahl der konvertierten Zeichen muss identisch sein Der zweite Parameter wird im Fall erklärt.

• Der zweite Parameter wird verwendet, um die konvertierten Zeichen anzugeben.

• Der dritte Parameter wird verwendet, um die zu löschenden Zeichen anzugeben.

Nachdem Sie eine Konvertierungstabelle definiert haben, können Sie mit print den Inhalt der Konvertierungstabelle drucken. Zu diesem Zeitpunkt wird ein Wörterbuch zurückgegeben und jeder Schlüssel:Wert in Das Wörterbuch ist Ist der Ordnungswert, der dem Zeichen entspricht.

Die Übersetzungsmethode übergibt die Konvertierungstabelle als Parameter und ruft sie dann mit der definierten Zeichenfolge auf, um schließlich die Zeichenkonvertierung zu erreichen.

1.2. Anwendungsfälle der Zeichenkonvertierung

1) Erstellung der Konvertierungstabelle

Bei der Definition der Konvertierungstabelle , Wenn mehrere konvertierte Zeichen angegeben werden, muss die Anzahl der konvertierten Zeichen mit der Anzahl der konvertierten Zeichen übereinstimmen. Zu diesem Zeitpunkt werden der erste Parameter und der zweite Parameter wie folgt kreuzkonvertiert.

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}
'''

Mit der Druckfunktion können Sie die Konvertierungstabelle ausdrucken. Der Wert im Wörterbuch ist der Ordnungswert des entsprechenden Zeichens Welche Zeichen werden in welche Zeichen konvertiert, wie unten gezeigt, 97 ist das Zeichen a, 55 ist das Zeichen 7, die Zeichen, die 97 entsprechen, werden in die Zeichen umgewandelt, die 55 entsprechen.

Zusätzlich zur direkten Deklaration des ursprünglichen Werts des konvertierten Zeichens und des konvertierten Zeichens in Form einer Zeichenfolge können Sie auch die Wörterbuchmethode verwenden Um die Konvertierung und die konvertierten Zeichen zu deklarieren, da das von der Konvertierungstabelle zurückgegebene Ergebnis ein Wörterbuch ist, besteht die häufigste Methode darin, die konvertierten Zeichen direkt in der Konvertierungstabelle zu deklarieren.

#使用字典的形式，在字典中声明转换的字符、被转换字符的原始值
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) Zeichenkonvertierung

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

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

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

#输出结果：ji7n89lupl7der

Es wurde festgestellt, dass alle a-Zeichen in der Zeichenfolge in 7 umgewandelt wurden und alle g-Zeichen in 8 umgewandelt, und alle x Zeichen werden in 9 umgewandelt.

3) Die maketrans-Methode kann beim Definieren der Konvertierungstabelle auch die zu löschenden Zeichen angeben, z. B. das Löschen der Zeichen u und p

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

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

#输出结果：ji7n89ll7der

4) In der Konvertierungstabelle der maketrans-Methodendefinition können Sie auch keine Zeichen konvertieren und nur bestimmte löschen Zeichen, wie z. B. Nur die Zeichen u und p löschen. Die Zeichen sind auf Keine Objekte festgelegt.

2. Das Konzept der Stringaufteilung

#🎜🎜 #Das so- Die sogenannte Zeichenfolgenaufteilung bezieht sich auf die Aufteilung der Zeichenfolge in N Teile gemäß dem angegebenen Trennzeichen, z. B. der Zeichenfolge „aaa bbb“. ", das ist die Aufteilung der Zeichenfolge. Es gibt zwei Möglichkeiten, eine Zeichenfolge zu teilen:

1) Rufen Sie die Methode split oder rsplit auf, um die Zeichenfolge zu teilen

# 🎜🎜Die #split-Methode besteht darin, die Saite von der linken Seite der Saite und von vorne nach hinten zu teilen.

rsplit-Methode besteht darin, die Saite von der rechten Seite der Saite ausgehend von hinten nach vorne zu teilen.

Die Methoden split und rsplit teilen alle Stellen, an denen das Trennzeichen in der Zeichenfolge erscheint, entsprechend dem Trennzeichen auf.

• Das Standardtrennzeichen ist eine Leerzeichenfolge. Wenn die maximale Anzahl von Teilungen durch diese beiden Methoden nicht angegeben wird, gibt es keinen Unterschied im Ausgabeinhalt und der Rückgabewert beider Methoden ist eine 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

  

  Das obige ist der detaillierte Inhalt vonSo lösen Sie die Probleme der Zeichenkonvertierung, String-Aufteilung und String-Zusammenführung in Python-Strings. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!