Python Basic Series- (3) detaillierte Einführung von Strings

Ziele:
 Zeichenfolgen
erkennen

Index  Slicing  Allgemeine Operationsmethoden

1 Grundlegendes zu Zeichenfolgen
Zeichenfolgen sind der in Python am häufigsten verwendete Datentyp. Zum Erstellen von Zeichenfolgen werden im Allgemeinen Anführungszeichen verwendet. Das Erstellen einer Zeichenfolge ist einfach. Weisen Sie ihr einfach eine Variable zu.
Z.B:

a = 'hello world'
b = "abcdefg"
print(type(a))
print(type(b))

1.1 String-Eigenschaften

# 一对引号字符串
name1 = 'Tom'
name2 = 'Rose'

# 三引号字符串
name3 = '''Tom'''
name4 = """Rose"""
a = '''i am Tom,
        nice to meet you !'''
print(a)
b = """i am Rose,
        nice to meet you!"""
print(b)
# 三引号形式的字符串支持换行
# 如果创建一个字符串I'm Tom?
c = "I'm Tom"
d = 'I\'m Tom'  # 这里的单引号注意一下！
print(c)
print(d)

1.2 String-Ein- und Ausgabe

# 字符串的输出
print('hello world')
name = 'Tom'
print('我的名字是%s' % name)
print(f'我的名字是{name}')

# 字符串的输入
# 在Python中，使用input()接收用户输入
password = input('请输入您的密码：')
print(f'您输入的密码是{password}')
print(type(password))

2 Index

Der Index wird auch als Index bezeichnet, bei dem es sich um die Nummer handelt. Zum Beispiel Zugsitznummer, die Rolle der Sitznummer: Finden Sie schnell den entsprechenden Sitzplatz entsprechend der Nummer.
Ähnlich: Die Funktion von Indizes besteht darin, entsprechende Daten schnell durch Indizes zu finden.

str1 = 'abc'
print(str1)
"""
1.数据在程序运行过程中存储在内存
2.如何得到数据a字符，b字符等？即如何使用字符串中的某个特定的数据？
3.这些字符数据从0开始顺序分配一个编号---使用这个编号精确找到某个字符数据
下标或索引或索引值
str1[下标]
"""
print(str1[0])
print(str1[1])
print(str1[2])

"""
输出结果：
abc
a
b
c
"""

3 Scheiben

Das Schneiden bezieht sich auf die Operation des Abfangens eines Teils des Operationsobjekts. Zeichenfolgen, Listen und Tupel unterstützen alle Slice-Operationen.
3.1 Slicing-Syntax
Sequenz [Startpositionsindex: Endpositionsindex: Schrittlänge]
Hinweis:
1. Start- und Endindex sind links geschlossen und rechts offen, dh sie enthalten nicht die Daten, die der Endposition entsprechen, und sowohl positive als auch negative Zahlen sind akzeptabel.
2. Die Schrittlänge ist das Auswahlintervall. Sowohl positive als auch negative Ganzzahlen sind zulässig. Die Standardschrittlänge ist 1.
Beispiel 1:

name = "abcdefg"
print(name[2:5:1])  # cde
print(name[2:5])   # cde
print(name[:5])  # abcde
print(name[1:])   # bcdefg

Beispiel 2:

# 序列名[开始下标位置：结束下标位置：步长]
str1 = '012345678'
print(str1[2:5:1])   # 234
print(str1[2:5:2])   # 24
print(str1[2:5])    # 234
print(str1[:5])     # 01234---如果不写开始，默认从0开始
print(str1[2:])     # 2345678---如果不写结束，默认选取到最后
print(str1[:])      # 012345678---如果不写开始和结束，表示选取全部

# 负数测试
print(str1[::-1])   # 876543210---步长为负数，表示倒叙选取
print(str1[-4:-1])  # 567---下标-1表示最后一个数据，一次向前类推

# 终极测试 str1 = '012345678'
print(str1[-4:-1:1])    # 567

print(str1[-4:-1:-1])
# 不能选取出数据：从-4开始到-1结束，选取方向从左到右，而步长-1表示从右向左选取
# ***如果选取方向（下标开始到结束的方向）和步长的方向冲突，则无法选取数据

4 Allgemeine Betriebsmethoden

4.1 Suche Die
sogenannte String-Suchmethode besteht darin, die Position oder Anzahl der Vorkommen des Teilstrings in dem String zu ermitteln.
 find () - Überprüfen Sie, ob eine bestimmte Teilzeichenfolge in der Zeichenfolge enthalten ist. Wenn dies der Fall ist, geben Sie den Index der Startposition der Teilzeichenfolge zurück, andernfalls -1.

# 语法：字符串序列.find(子串，开始下标，结束位置下标)
# 注意：开始，结束位置下标可以省略，表示在整个字符串序列中查找
mystr = "hello world and itcast and itheima and Python"
print(mystr.find('and'))   # 12
print(mystr.find('and', 15, 30))  # 23
print(mystr.find('ands'))  # -1

 index () - Überprüfen Sie, ob eine bestimmte Teilzeichenfolge in dieser Zeichenfolge enthalten ist, und geben Sie den Index am Anfang der Teilzeichenfolge zurück. Andernfalls wird eine Ausnahme gemeldet.

# 语法：字符串序列.index(子串，开始位置下标，结束下标位置)
# 注意：开始，结束位置下标可以省略，表示在整个字符串序列中查找
mystr = "hello world and itcast and itheima and Python"
print(mystr.index('and'))  # 12
print(mystr.index('and', 15, 30))  # 23
print(mystr.index('ands'))  # 报错

 rfind () - gleiche Funktion wie find (), aber die Suchrichtung beginnt von rechts
 rindex () - funktioniert genauso wie index (), aber die Suchrichtung beginnt von rechts
 count () - gibt einen bestimmten Teilstring zurück Anzahl der Vorkommen in der Zeichenfolge

# 语法：字符串序列.count(子串，开始位置下标，结束下标位置)
# 注意：开始，结束位置下标可以省略，表示在整个字符串序列中查找

Beispiel:

mystr = "hello world and itcast and itheima and Python"
# 1,rfind()
print(mystr.rfind('and'))  # 35
print(mystr.rfind('ands'))  #-1
# 2,rindex()
print(mystr.rindex('and'))  #35
# print(mystr.rindex('ands'))  # 报错
# 3,count()
print(mystr.count('and', 15, 30))  # 1
print(mystr.count('and'))  # 3
print(mystr.count('ands'))  # 0

4.2 Änderung Die
sogenannte Änderung einer Zeichenfolge bezieht sich auf die Änderung der Daten in der Zeichenfolge in Form einer Funktion.
4.2.1 Allgemeine Änderungen
 replace () ---- replace

mystr = "hello world and itcast and itheima and Python"
print(mystr.replace('and', 'he'))
# 结果hello world he itcast he itheima he Python
print(mystr.replace('and', 'he', 10))
# 结果hello world he itcast he itheima he Python
print(mystr)
# 结果hello world and itcast and itheima and Python
语法：字符串序列.replace(旧子串，新子串，替换次数)
注意：替换次数如果超出子串出现次数，则替换次数为该子串出现的次数

Hinweis: Die Daten können in Variablentypen und unveränderliche Typen unterteilt werden, je nachdem, ob sie direkt geändert werden können. Wenn die Daten des Zeichenfolgentyps geändert werden, kann die ursprüngliche Zeichenfolge nicht geändert werden. Sie gehört zu dem Typ, der die Daten nicht direkt ändern kann, dh dem unveränderlichen Typ.

 split () ---- Teilen Sie die Zeichenfolge gemäß dem angegebenen Zeichen.
Hinweis: Wenn das geteilte Zeichen eine Teilzeichenfolge der ursprünglichen Zeichenfolge ist, geht die Teilzeichenfolge nach dem Teilen verloren.

mystr = "hello world and itcast and itheima and Python"
print(mystr.split('and'))
# 结果：['hello world ', ' itcast ', ' itheima ', ' Python']
print(mystr.split('and', 2))
# 结果：['hello world ', ' itcast ', ' itheima and Python']
print(mystr.split(' '))
# 结果：['hello', 'world', 'and', 'itcast', 'and', 'itheima', 'and', 'Python']
print(mystr.split(' ', 2))
# 结果：['hello', 'world', 'and itcast and itheima and Python']

 join () - Kombinieren Sie Zeichenfolgen mit einem Zeichen oder einer Teilzeichenfolge, dh kombinieren Sie mehrere Zeichenfolgen zu einer neuen Zeichenfolge.

# join语法---字符或子串.join(多字符组成的序列)
mylist = ['aa', 'bb', 'cc']
new_str = '...'.join(mylist)
print(new_str)
# 结果：aa...bb...cc

4.2.2 Die Änderungen müssen bekannt sein

 großschreiben () ---- Konvertieren des ersten Zeichens der Zeichenfolge in Großbuchstaben
Hinweis: Nach der Konvertierung der Funktion großschreiben () wird nur das erste Zeichen der Zeichenfolge in Großbuchstaben und alle anderen Zeichen in Kleinbuchstaben geschrieben.
 title () ---- konvertiert den ersten Buchstaben jedes Wortes der Zeichenfolge in Großbuchstaben.
 Kleinbuchstaben () ---- Großbuchstaben in einer Zeichenfolge in Kleinbuchstaben
ändern  Großbuchstaben () ---- Kleinbuchstaben in einer Zeichenfolge in Großbuchstaben ändern
Beispiel:

mystr = "hello world and itcast and itheima and Python"
# 1，解释：将第一个字符转换成大写
#  结果：Hello world and itcast and itheima and python
print(mystr.capitalize())

# 2，解释：将每个单词首字母转成大写
#  结果：Hello World And Itcast And Itheima And Python
print(mystr.title())

# 3，解释：将字符串中的大写转换为小写
#  结果：hello world and itcast and itheima and python
print(mystr.lower())

# 4，解释：将字符串中的小写转大写
#  结果：HELLO WORLD AND ITCAST AND ITHEIMA AND PYTHON
print(mystr.upper())

 Löschen Sie den leeren Funktionsstreifen
() ---- Löschen Sie die leeren Zeichen auf beiden Seiten des Strings
lstrip () ---- Löschen Sie das linke leere Zeichen des Strings
rstrip () ---- Löschen Sie das leere Zeichen auf der rechten Seite des Strings.
Beispiel:

 Ausrichten Die Funktion
Ijust () ---- gibt eine neue Zeichenfolge zurück, wobei die ursprüngliche Zeichenfolge linksbündig ausgerichtet und mit den angegebenen Zeichen (Standardzeichen) auf die entsprechende Länge gefüllt ist.

# 语法：字符串序列.ljust(长度，填充个字符)

rjust () ---- gibt eine neue Zeichenfolge zurück, wobei die ursprüngliche Zeichenfolge rechtsbündig ausgerichtet und mit den angegebenen Zeichen (Standardzeichen) auf die entsprechende Länge gefüllt ist. Die Syntax entspricht ljust ().
center () ---- gibt eine neue Zeichenfolge zurück, wobei die ursprüngliche Zeichenfolge in der Mitte ausgerichtet und mit den angegebenen Zeichen (Standardzeichen) auf die entsprechende Länge gefüllt ist. Die Syntax entspricht ljust ().
Beispiel:

4.3 Beurteilung Die
sogenannte Beurteilung besteht darin, wahr oder falsch zu beurteilen, und das zurückgegebene Ergebnis sind boolesche Daten: Wahr oder falsch
 Start mit () - Überprüfen Sie, ob die Zeichenfolge mit der angegebenen Teilzeichenfolge beginnt. Wenn ja, geben Sie Wahr zurück, andernfalls Falsch. Wenn Sie die Indizes für Start- und Endposition festlegen, überprüfen Sie diese innerhalb des angegebenen Bereichs.
Syntax:
Zeichenfolgenfolge. Satrtswith (Teilzeichenfolge, Startpositionsindex, Endpositionsindex)
Beispiel:

mystr = "hello world and itcast and itheima and Python"
# 1，startswith():判断字符串是否以某个子串开头
print(mystr.startswith('hello'))
print(mystr.startswith('hel'))
print(mystr.startswith('hels'))

# 2,endswith():判断字符串是否以某个子串结尾
print(mystr.endswith('Python'))
print(mystr.endswith('Pythons'))

 isalpha () - Wenn die Zeichenfolge mindestens ein Zeichen enthält und alle Zeichen Buchstaben sind, wird True zurückgegeben und umgekehrt.

mystr1 = 'hello'
mystr2 = 'hello12345'
print(mystr1.isalpha())
print(mystr2.isalpha())

 isdigit () - Wenn die Zeichenfolge nur Ziffern enthält, wird True zurückgegeben und umgekehrt.
 isalnum () - gibt True zurück, wenn die Zeichenfolge mindestens ein Zeichen enthält und alle Zeichen Buchstaben oder Zahlen sind und umgekehrt.

mystr1 = 'aaa12345'
mystr2 = '12345'
print(mystr1.isdigit())
print(mystr2.isdigit())

print(mystr1.isalnum())
print(mystr2.isalnum())

 isspace () ---- Wenn die Zeichenfolge nur Leerzeichen enthält, wird True zurückgegeben und umgekehrt.

mystr3 = '1 2 3 4 5'
mystr4 = '     '
print(mystr3.isspace())
print(mystr4.isspace())

Es gibt so viele Einführungen über Streicher, Freunde, die es mögen, sollten es sammeln!