Ein ausführliches Tutorial (55+ Code Beispiele)

Datentypen helfen uns, Datenelemente zu kategorisieren. Sie bestimmen die Arten von Operationen, die wir mit einem Datenelement ausführen können. In Python der gemeinsame Customary Datentypen enthalten ZahlenAnwesend SaiteAnwesend ListeAnwesend TupelAnwesend booleanAnwesend SatzUnd Wörterbuch.

In diesem Tutorial konzentrieren wir uns auf den String -Datentyp. Wir werden diskutieren, wie der String -Datentyp, die Beziehung zwischen dem String -Datentyp und der ASCII -Tabelle, den Eigenschaften des String -Datentyps und einigen wichtigen String -Methoden und -Operationen deklariert werden.

Was sind Python -Saiten?

A Saite ist ein Objekt, das eine Abfolge von Zeichen enthält. Ein Zeichen ist eine Längeschnur. Ein einzelnes Zeichen ist auch eine Schnur in Python. Ironischerweise fehlt der Charakterdatentyp in der Python -Programmiersprache. Wir finden jedoch den Charakterdatentyp in anderen Programmiersprachen wie C, Kotlin und Java.

Wir können eine Python -Zeichenfolge mit einem einzigen Zitat, einem doppelten Zitat, einem dreifachen Zitat oder dem deklarieren str() Funktion. Das folgende Code -Snippet zeigt, wie eine Zeichenfolge in Python deklariert werden soll:

# A single quote string
single_quote = 'a'  # That is an instance of a personality in different programming languages. It's a string in Python

# One other single quote string
another_single_quote = 'Programming teaches you endurance.'

# A double quote string
double_quote = "aa"

# One other double-quote string
another_double_quote = "It's unattainable till it's finished!"

# A triple quote string
triple_quote = '''aaa'''

# Additionally a triple quote string
another_triple_quote = """Welcome to the Python programming language. Prepared, 1, 2, 3, Go!"""

# Utilizing the str() perform
string_function = str(123.45)  # str() converts float information kind to string information kind

# One other str() perform
another_string_function = str(True)  # str() converts a boolean information kind to string information kind

# An empty string
empty_string = ''

# Additionally an empty string
second_empty_string = ""

# We aren't finished but
third_empty_string = """"""  # That is additionally an empty string: ''''''

Eine andere Möglichkeit, Saiten in Python zu bekommen enter() Funktion. Der enter() Mit der Funktion können wir Werte in ein Programm mit der Tastatur einfügen. Die eingefügten Werte werden als Zeichenfolge gelesen, aber wir können sie in andere Datentypen umwandeln:

# Inputs right into a Python program
input_float = enter()  # Kind in: 3.142
input_boolean = enter() # Kind in: True

# Convert inputs into different information varieties
convert_float = float(input_float)  # converts the string information kind to a float
convert_boolean = bool(input_boolean) # converts the string information kind to a bool

Wir benutzen die kind() Funktion zur Bestimmung des Datentyps eines Objekts in Python. Es gibt die Klasse des Objekts zurück. Wenn das Objekt eine Zeichenfolge ist, gibt es die zurück str Klasse. Ebenso kehrt es zurück dictAnwesend intAnwesend floatAnwesend tupleAnwesend bool Klasse Wenn das Objekt ein Wörterbuch, eine Ganzzahl, Schwimmer, Tupel bzw. Booleschen ist. Lassen Sie uns jetzt die verwenden kind() Funktion zur Bestimmung der Datentypen von Variablen, die in den vorherigen Code -Snippets deklariert sind:

# Knowledge varieties/ lessons with kind()

print(kind(single_quote))
print(kind(another_triple_quote))
print(kind(empty_string))

print(kind(input_float))
print(kind(input_boolean))

print(kind(convert_float))
print(kind(convert_boolean))

<class 'str'>
<class 'str'>
<class 'str'>
<class 'float'>
<class 'bool'>
<class 'float'>
<class 'bool'>

Wir haben besprochen, wie man Strings deklariert. Gehen wir nun zur Beziehung zwischen Saiten und der ASCII -Tabelle.

Die ASCII -Tabelle vs. Python String -Zeichen

Der amerikanische Standardcode für Informationsaustausch (ASCII) wurde entwickelt, um uns zu helfen, Zeichen oder Texte zu Zahlen zu kartieren, da die Zahlensätze im Computerspeicher einfacher zu speichern sind als Texte. ASCII codiert 128 Zeichen hauptsächlich in der englischen Sprache, die bei der Verarbeitung von Informationen in Computern und der Programmierung verwendet werden. Die von ASCII codierten englischen Zeichen umfassen Kleinbuchstaben (AZ), Großbuchstaben (AZ), Ziffern (0-9) und Symbole wie Zeichenzeichen.

Der ord() Funktion wandelt eine Python -Zeichenfolge von 1 (ein Zeichen) in ihre Dezimalpräparation in der ASCII -Tabelle um, während die chr() Funktion konvertiert die Dezimalzahlung zurück in eine Zeichenfolge. Zum Beispiel:

import string

# Convert uppercase characters to their ASCII decimal numbers
ascii_upper_case = string.ascii_uppercase  # Output: ABCDEFGHIJKLMNOPQRSTUVWXYZ

for one_letter in ascii_upper_case(:5):  # Loop via ABCDE
    print(ord(one_letter))    

65
66
67
68
69

# Convert digit characters to their ASCII decimal numbers
ascii_digits = string.digits  # Output: 0123456789

for one_digit in ascii_digits(:5):  # Loop via 01234
    print(ord(one_digit)) 

48
49
50
51
52

Im obigen Code -Snippet haben wir uns durch Strings geschleudert ABCDE Und 01234und wir haben jeden Charakter in ihre Dezimalrepräsentation auf dem konvertiert ASCII -Tabelle. Wir können auch den umgekehrten Betrieb mit dem durchführen chr() Funktion, wobei wir Dezimalzahlen in die ASCII -Tabelle in ihre Python -String -Zeichen konvertieren. Zum Beispiel:

decimal_rep_ascii = (37, 44, 63, 82, 100)

for one_decimal in decimal_rep_ascii:
    print(chr(one_decimal))

%
,
?
R
d

In der ASCII -Tabelle sind die Zeichenfolgenzeichen in der Ausgabe der obigen Programmkarte zu ihren jeweiligen Dezimalzahlen. Bisher haben wir besprochen, wie man Python -Saiten deklariert und wie der Zeichenfolgenzeichen der ASCII -Tabelle kartiert. Lassen Sie uns als nächstes die Attribute einer Zeichenfolge diskutieren.

Zeichenfolge Eigenschaften

Nullindex: Das erste Component in einer Zeichenfolge hat einen Index von Null, während das letzte Component einen Index von hat len(string) - 1. Zum Beispiel:

immutable_string = "Accountability"

print(len(immutable_string))
print(immutable_string.index('A'))
print(immutable_string.index('y'))

14
0
13

Unveränderlichkeit. Dies bedeutet, dass wir die Zeichen nicht in einer Zeichenfolge aktualisieren können. Zum Beispiel können wir ein Component aus einer Zeichenfolge nicht löschen oder versuchen, ein neues Component an einer seiner Indexpositionen zuzuweisen. Wenn wir versuchen, die Zeichenfolge zu aktualisieren, wirft es a TypeError:

immutable_string = "Accountability"

# Assign a brand new aspect at index 0
immutable_string(0) = 'B'

---------------------------------------------------------------------------

TypeError                                 Traceback (most up-to-date name final)

~AppDataLocalTemp/ipykernel_11336/2351953155.py in <module>
      2 
      3 # Assign a brand new aspect at index 0
----> 4 immutable_string(0) = 'B'

TypeError: 'str' object doesn't assist merchandise task

Wir können jedoch eine Zeichenfolge auf die zuweisen immutable_string Variable, aber wir sollten beachten, dass sie nicht die gleiche Zeichenfolge sind, da sie nicht auf dasselbe Objekt im Speicher verweisen. Python aktualisiert das alte String -Objekt nicht. Es schafft eine neue, wie wir durch die IDs sehen können:

immutable_string = "Accountability"
print(id(immutable_string))

immutable_string = "Bccountability"  
print(id(immutable_string)

test_immutable = immutable_string
print(id(test_immutable))

2693751670576
2693751671024
2693751671024

Sie erhalten unterschiedliche IDs als die im Beispiel, weil wir unsere Programme auf verschiedenen Computern ausführen, sodass unsere Speicheradressen unterschiedlich sind. Beide IDs sollten jedoch auch auf demselben Pc unterschiedlich sein. Das bedeutet, dass beide immutable_string Variablen weisen auf verschiedene Adressen im Speicher hin. Wir haben den letzten zugewiesen immutable_string variabel zu test_immutable Variable. Sie können das sehen test_immutable variabel und die letzten immutable_string Variabler Punkt auf dieselbe Adresse.

Verkettung: Mit zwei oder mehr Saiten zusammen mit dem neuen Zeichenfolge mit dem erhalten + Image. Zum Beispiel:

first_string = "Knowledge"
second_string = "quest"
third_string = "Knowledge Science Path"

fourth_string = first_string + second_string
print(fourth_string)

fifth_string = fourth_string + " " + third_string
print(fifth_string)

Dataquest
Dataquest Knowledge Science Path

Wiederholung: Eine Zeichenfolge kann mit dem wiederholt werden * Image. Zum Beispiel:

print("Ha" * 3)

HaHaHa

Indizierung und Schneiden: Wir haben bereits festgestellt, dass Saiten null indexiert sind. Wir können auf jedes Component in einer Zeichenfolge mit seinem Indexwert zugreifen. Wir können auch Teilmengen einer Zeichenfolge einnehmen, indem wir zwischen zwei Indexwerten schneiden. Zum Beispiel:

main_string = "I discovered R and Python on Dataquest. You are able to do it too!"

# Index 0
print(main_string(0))

# Index 1
print(main_string(1))

# Examine if Index 1 is whitespace
print(main_string(1).isspace())

# Slicing 1
print(main_string(0:11))

# Slicing 2: 
print(main_string(-18:))

# Slicing and concatenation
print(main_string(0:11) + ". " + main_string(-18:))

I

True
I discovered R
You are able to do it too!
I discovered R. You are able to do it too!

Stringmethoden

str.cut up(sep=None, maxsplit=-1): Die String -Cut up -Methode enthält zwei Attribute: sep Und maxsplit. Wenn diese Methode mit ihren Standardwerten aufgerufen wird, spaltet sie die Zeichenfolge überall dort, wo es eine Weißespace gibt. Diese Methode gibt eine Liste von Zeichenfolgen zurück:

string = "Apple, Banana, Orange, Blueberry"
print(string.cut up())

('Apple,', 'Banana,', 'Orange,', 'Blueberry')

Wir können sehen, dass die Zeichenfolge nicht intestine aufgeteilt ist, weil die geteilte Zeichenfolge enthält ,. Wir können verwenden sep=',' wo immer es gibt, wo es ist ,:

print(string.cut up(sep=','))

('Apple', ' Banana', ' Orange', ' Blueberry')

Dies ist besser als der vorherige Cut up. Wir können jedoch die Whitespace vor einigen der geteilten Saiten sehen. Wir können dies mit entfernen (sep=', '):

# Discover the whitespace after the comma
print(string.cut up(sep=', '))

('Apple', 'Banana', 'Orange', 'Blueberry')

Jetzt ist die Saite schön aufgeteilt. Manchmal wollen wir nicht die maximale Anzahl trennen. Wir können die verwenden maxsplit Attribut, um die Häufigkeit anzugeben, mit der wir uns teilen möchten:

print(string.cut up(sep=', ', maxsplit=1))

print(string.cut up(sep=', ', maxsplit=2))

('Apple', 'Banana, Orange, Blueberry')
('Apple', 'Banana', 'Orange, Blueberry')

str.splitlines(keepends=False): Manchmal wollen wir einen Korpus mit unterschiedlichen Linienbrüchen verarbeiten ('n'Anwesend nn'Anwesend 'r'Anwesend 'rn') an den Grenzen. Wir wollen uns in Sätze teilen, nicht in einzelne Wörter. Wir werden die verwenden splitline Methode, dies zu tun. Wann keepends=TrueDie Zeilenpausen sind im Textual content enthalten; Ansonsten sind sie ausgeschlossen. Lassen Sie uns sehen, wie dies mit dem Macbeth -Textual content von Shakespeare gemacht wird:

import nltk  # You could have to pip set up nltk to make use of this library.

macbeth = nltk.corpus.gutenberg.uncooked('shakespeare-macbeth.txt')
print(macbeth.splitlines(keepends=True)(:5))

('(The Tragedie of Macbeth by William Shakespeare 1603)n', 'n', 'n', 'Actus Primus. Scoena Prima.n', 'n')

str.strip((chars)): Wir entfernen nachfolgende Weißespaien oder Zeichen von beiden Seiten der Saite mit dem strip Verfahren. Zum Beispiel:

string = "    Apple Apple Apple no apple within the field apple apple             "

stripped_string = string.strip()
print(stripped_string)

left_stripped_string = (
    stripped_string
    .lstrip('Apple')
    .lstrip()
    .lstrip('Apple')
    .lstrip()
    .lstrip('Apple')
    .lstrip()
)
print(left_stripped_string)

capitalized_string = left_stripped_string.capitalize()
print(capitalized_string)

right_stripped_string = (
    capitalized_string
    .rstrip('apple')
    .rstrip()
    .rstrip('apple')
    .rstrip()
)
print(right_stripped_string)

Apple Apple Apple no apple within the field apple apple
no apple within the field apple apple
No apple within the field apple apple
No apple within the field

Im obigen Code -Snippet haben wir die verwendet lstrip Und rstrip Methoden, die nachverfolgende Weißespaien oder Zeichen von der linken und rechten Seite der Zeichenfolge entfernen. Wir haben auch die benutzt capitalize Methode, die eine Zeichenfolge in einen Satzfall umwandelt.

str.zfill(width): Der zfill Methode pads eine Zeichenfolge mit 0 Präfix, um die angegebenen zu erhalten width. Zum Beispiel:

instance = "0.8"  # len(instance) is 3
example_zfill = instance.zfill(5) # len(example_zfill) is 5
print(example_zfill)

000.8

str.isalpha(): Diese Methode kehrt zurück True Wenn alle Zeichen in der Zeichenfolge Alphabete sind; Ansonsten kehrt es zurück False:

# Alphabet string
alphabet_one = "Studying"
print(alphabet_one.isalpha())

# Incorporates whitspace
alphabet_two = "Studying Python"
print(alphabet_two.isalpha())

# Incorporates comma symbols
alphabet_three = "Studying,"
print(alphabet_three.isalpha())

True
False
False

Ähnlich, str.isalnum() zurück True Wenn die String -Zeichen alphanumerisch sind; str.isdecimal() zurück True Wenn die String -Zeichen dezimal sind; str.isdigit() zurück True Wenn die Zeichenfolgenzeichen Ziffern sind; Und str.isnumeric() zurück True Wenn die String -Zeichen numerisch sind.

str.islower() zurück True Wenn alle Zeichen in der Zeichenfolge Kleinbuchstaben sind. str.isupper() zurück True Wenn alle Zeichen in der Zeichenfolge Großbuchstaben sind, und str.istitle() zurück True Wenn der erste Buchstabe jedes Wortes aktiviert wird:

# islower() instance
string_one = "Synthetic Neural Community"
print(string_one.islower())

string_two = string_one.decrease()  # converts string to lowercase
print(string_two.islower())

# isupper() instance
string_three = string_one.higher() # converts string to uppercase
print(string_three.isupper())

# istitle() instance
print(string_one.istitle())

False
True
True
True

str.endswith(suffix) zurück True ist die Zeichenfolge endet mit dem angegebenen Suffix. str.startswith(prefix) zurück True Wenn die Zeichenfolge mit dem angegebenen Präfix beginnt:

sentences = ('Time to grasp information science', 'I really like statistical computing', 'Eat, sleep, code')

# endswith() instance
for one_sentence in sentences:
    print(one_sentence.endswith(('science', 'computing', 'Code')))

True
True
False

# startswith() instance
for one_sentence in sentences:
    print(one_sentence.startswith(('Time', 'I ', 'Ea')))

True
True
True

str.discover(substring) Gibt den niedrigsten Index zurück, wenn das Substring in der Zeichenfolge vorhanden ist. Ansonsten gibt es -1 zurück. str.rfind(substring) Gibt den höchsten Index zurück. Der str.index(substring) Und str.rindex(substring) Geben Sie auch den niedrigsten und höchsten Index des Substring zurück, wenn er gefunden wird. Wenn das Substring in der Saite nicht vorhanden ist, erhöhen sie ValueError.

string = "programming"

# discover() and rfind() examples
print(string.discover('m'))
print(string.discover('professional'))
print(string.rfind('m'))
print(string.rfind('recreation'))

# index() and rindex() examples
print(string.index('m'))
print(string.index('professional'))
print(string.rindex('m'))
print(string.rindex('recreation'))

6
0
7
-1
6
0
7

---------------------------------------------------------------------------

ValueError                                Traceback (most up-to-date name final)

~AppDataLocalTemp/ipykernel_11336/3954098241.py in <module>
     11 print(string.index('professional'))  # Output: 0
     12 print(string.rindex('m'))  # Output: 7
---> 13 print(string.rindex('recreation'))  # Output: ValueError: substring not discovered

ValueError: substring not discovered

str.maketrans(dict_map) erstellt eine Übersetzungstabelle aus einer Wörterbuchkarte und str.translate(maketrans) Ersetzen Sie Elemente in der Übersetzung mit ihren neuen Werten. Zum Beispiel:

instance = "abcde"
mapped = {'a':'1', 'b':'2', 'c':'3', 'd':'4', 'e':'5'}
print(instance.translate(instance.maketrans(mapped))) 

12345

Stringoperationen

Durch eine Zeichenfolge schaufeln. Saiten sind iterbar. Daher unterstützen sie die Schleifenoperationen mit for loop Und enumerate:

# For-loop instance
phrase = "financial institution"
for letter in phrase:
    print(letter)

b
a
n
okay

# Enumerate instance
for idx, worth in enumerate(phrase):
    print(idx, worth)

0 b
1 a
2 n
3 okay

String und relationale Operatoren: Wenn zwei Zeichenfolgen mit relationalen Operatoren verglichen werden (>Anwesend <Anwesend ==usw.), die Elemente der beiden Saiten werden mit ihrem ASCII -Dezimalzahlen -Index nach Index verglichen. Zum Beispiel:

print('a' > 'b')
print('abc' > 'b')

False
False

In beiden Fällen ist der Ausgang False. Der relationale Operator verglichen zunächst die ASCII -Dezimalzahl der Elemente im Index 0 Für beide Saiten. Seit b ist größer als aes kehrt zurück False; Die ASCII -Dezimalzahl der anderen Elemente und die Länge der Saiten spielt in diesem Fall keine Rolle.

Wenn die Saiten derselben Länge haben, vergleicht sie die ASCII -Dezimalzahl jedes Components aus dem Index 0 bis es Elemente mit unterschiedlichen ASCII -Dezimalzahlen findet. Zum Beispiel:

print('abd' > 'abc')

True

Im obigen Code -Snippet haben die ersten beiden Elemente die gleichen ASCII -Dezimalzahlen; Es gibt jedoch ein Missverhältnis im dritten Component und seitdem d ist größer als ces kehrt zurück True. In einer State of affairs, in der alle ASCII -Zahlen für die Elemente übereinstimmen, ist die längere Saite größer als die kürzere. Zum Beispiel:

print('abcd' > 'abc')

True

Überprüfen Sie die Mitgliedschaft in einer Zeichenfolge. Der in Der Bediener wird verwendet, um zu überprüfen, ob ein Substring ein Mitglied einer Zeichenfolge ist:

print('information' in 'dataquest')
print('gram' in 'programming')

True
True

Eine andere Möglichkeit, die Mitgliedschaft einer Zeichenfolge zu überprüfen, ein Substring zu ersetzen oder das Match -Muster zu übereinstimmen Regelmäßiger Ausdruck

import re

substring = 'gram'
string = 'programming'
substitute = '1234'

# Examine membership
print(re.search(substring, string))

# Substitute string
print(re.sub(substring, substitute, string))

<re.Match object; span=(3, 7), match="gram">
pro1234ming

String -Formatierung. f-string Und str.format() Methoden werden verwendet, um Zeichenfolgen zu formatieren. Beide verwenden Curly Bracket {} Platzhalter. Zum Beispiel:

monday, tuesday, wednesday = "Monday", "Tuesday", "Wednesday"

format_string_one = "{} {} {}".format(monday, tuesday, wednesday)
print(format_string_one)

format_string_two = "{2} {1} {0}".format(monday, tuesday, wednesday)
print(format_string_two)

format_string_three = "{one} {two} {three}".format(one=tuesday, two=wednesday, three=monday)
print(format_string_three)

format_string_four = f"{monday} {tuesday} {wednesday}"
print(format_string_four)

Monday Tuesday Wednesday
Wednesday Tuesday Monday
Tuesday Wednesday Monday
Monday Tuesday Wednesday

f-strings sind lesbarer und implementieren schneller als die str.format() Verfahren. Daher, f-string ist die bevorzugte Methode zur Stringformatierung.

Umgang mit Zitat und Apostroph: Das Apostrophzeichen (') repräsentiert eine Zeichenfolge in Python. Um Python wissen zu lassen, dass wir nicht mit einer Schnur zu tun haben, müssen wir den Python Escape -Charakter verwenden (). Ein Apostroph wird additionally als dargestellt als ' in Python. Im Gegensatz zum Umgang mit Apostrophes gibt es viele Möglichkeiten, in Python Zitate zu behandeln. Dazu gehören Folgendes:

# 1. Symbolize string with single quote ('') and quoted assertion with double quote ("")
quotes_one =  '"Buddies do not let mates use minibatches bigger than 32" - Yann LeCun'
print(quotes_one)

# 2. Symbolize string with double quote ("") and quoted assertion with escape and double quote ("assertion")
quotes_two =  ""Buddies do not let mates use minibatches bigger than 32" - Yann LeCun"
print(quotes_two)

# 3. Symbolize string (actually) with triple quote ("""""") and quoted statment with double quote ("")
quote_three = """"Buddies do not let mates use minibatches bigger than 32" - Yann LeCun"""
print(quote_three)

"Buddies do not let mates use minibatches bigger than 32" - Yann LeCun
"Buddies do not let mates use minibatches bigger than 32" - Yann LeCun
"Buddies do not let mates use minibatches bigger than 32" - Yann LeCun

Abschluss

Python -Saiten sind unveränderlich und einer der grundlegenden Datentypen. Wir können sie mit einzelnen, doppelten oder dreifachen Zitaten oder mit dem deklarieren str() Funktion.

Wir können jedes Component einer Zeichenfolge einer Zahl in der ASCII -Tabelle zuordnen. Dies ist die Eigenschaft, die wir verwenden, wenn Zeichenfolgen mit relationalen Operatoren verglichen werden. Es stehen viele Methoden zur Verarbeitung von Zeichenfolgen zur Verfügung.

In diesem Artikel werden die am häufigsten verwendeten dargelegt, die Methoden zum Aufteilen von Zeichenfolgen, das Überprüfen von Begin- und Beendungszeichen, das Polsterung, das Überprüfen von String -Fall und das Ersetzen von Elementen in einer String enthalten. Wir haben auch String -Operationen zum Schleifen durch die Mitglieder einer Zeichenfolge, die Überprüfung der String -Mitgliedschaft, die Formatierung von Saiten und die Handhabung von Anführungszeichen und Apostrophen besprochen.