Strings vergelijken met Python

In Python zijn strings reeksen karakters, die effectief als een object in het geheugen worden opgeslagen. Elk object kan worden geïdentificeerd met behulp van de id() methode, zoals u hieronder kunt zien. Python probeert objecten in het geheugen te hergebruiken die dezelfde waarde hebben, waardoor het vergelijken van objecten ook erg snel gaat in Python:

$ python
Python 3.9.0 (v3.9.0:9cf6752276, Oct  5 2020, 11:29:23) 
[Clang 6.0 (clang-600.0.57)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> a = "abc"
>>> b = "abc"
>>> c = "def"
>>> print (id(a), id(b), id(c))
(139949123041320, 139949123041320, 139949122390576)
>>> quit()

Om strings te vergelijken, biedt Python een aantal verschillende operatoren om dit te doen. Eerst zullen we ze hieronder nader toelichten. Ten tweede zullen we beide bespreken string en re modules, die methoden bevatten om hoofdletterongevoelige en onnauwkeurige overeenkomsten af ​​te handelen. Ten derde, om om te gaan met tekenreeksen met meerdere regels is het difflib-module is best handig. Een aantal voorbeelden zullen u helpen te begrijpen hoe u ze kunt gebruiken.

Vergelijk strings met de operatoren The == en !=

Als basisvergelijkingsoperator die u wilt gebruiken == en !=. Ze werken op precies dezelfde manier als bij integer- en float-waarden. De == operator keert terug True als er een exacte match is, anders False zal worden geretourneerd. Daarentegen is de != operator keert terug True als er geen match is en anders terugkeert False. Lijst 1 toont dit aan.

In een for loop wordt een string met de naam van de Zwitserse stad “Lausanne” vergeleken met een vermelding uit een lijst met andere plaatsen, en het vergelijkingsresultaat wordt afgedrukt op stdout.

Lijst 1:

listOfPlaces = ["Berlin", "Paris", "Lausanne"]
currentCity = "Lausanne"

for place in listOfPlaces:
    print (f"comparing {place} with {currentCity}: %{place == currentCity}")

Als u het Python-script van bovenaf uitvoert, is de uitvoer als volgt:

$ python3 comparing-strings.py
comparing Berlin with Lausanne: False
comparing Paris with Lausanne: False
comparing Lausanne with Lausanne: True

De == en is Operators

Python heeft de twee vergelijkingsoperatoren == en is. Op het eerste gezicht lijken ze hetzelfde, maar dat is niet zo.

== vergelijkt twee variabelen op basis van de waarde die ze vertegenwoordigen. Daarentegen is de is operator vergelijkt twee variabelen op basis van de object-ID in het geheugen.

John (Doe) en John (Moe) heten allebei John. Als we ze kunnen herleiden tot alleen hun naam, zouden ze qua waarde gelijk zijn, maar kwalitatief nog steeds twee verschillende mensen.

Het volgende voorbeeld laat dit zien voor drie variabelen met tekenreekswaarden. De twee variabelen a en b hebben dezelfde waarde, en Python verwijst naar hetzelfde object om het geheugengebruik te minimaliseren.

Dit wordt standaard gedaan voor eenvoudige typen en tekenreeksen, maar niet voor andere objecten:

>>> a = 'hello'
>>> b = 'hello'
>>> c = 'world'
>>> a is b
True
>>> a is c
False
>>> id(a)
140666888153840
>>> id(b)
140666888153840
>>> 

Zodra de waarde verandert, zal Python het object opnieuw maken en de variabele toewijzen. In het volgende codefragment b krijgt de waarde 2, en vervolgens b en c verwijzen naar hetzelfde object:

>>> b = 'world'
>>> id(b)
140666888154416
>>> id(c)
140666888154416

Meer vergelijkingsoperatoren

Voor een vergelijking met betrekking tot een lexicografische volgorde kunt u de vergelijkingsoperatoren gebruiken <, >, <= en >=. De vergelijking zelf gebeurt karakter voor karakter. De volgorde is afhankelijk van de volgorde van de tekens in het alfabet. Deze volgorde is afhankelijk van de tekentabel die op uw machine wordt gebruikt tijdens het uitvoeren van de Python-code.

Houd er rekening mee dat de volgorde hoofdlettergevoelig is. Als voorbeeld voor het Latijnse alfabet komt ‘Bus’ vóór ‘bus’. Lijst 2 laat zien hoe deze vergelijkingsoperatoren in de praktijk werken.

Lijst 2:

listOfPlaces = ["Berlin", "Paris", "Lausanne"]
currentCity = "Lausanne"

for place in listOfPlaces:
    if place < currentCity:
            print (f"{place} comes before {currentCity}")
    elif place > currentCity:
            print (f"{place} comes after {currentCity}")
    else:
            print (f"{place} is equal to {currentCity}")

Als u het Python-script van bovenaf uitvoert, is de uitvoer als volgt:

$ python3 comparing-strings-order.py
Berlin comes before Lausanne
Paris comes after Lausanne
Lausanne is equal to Lausanne

Hoofdletterongevoelige tekenreeksvergelijkingen

De voorgaande voorbeelden waren gericht op exacte overeenkomsten tussen tekenreeksen. Om hoofdletterongevoelige vergelijkingen mogelijk te maken, biedt Python speciale stringmethoden zoals upper() en lower(). Beide zijn direct beschikbaar als methoden van het overeenkomstige stringobject.

upper() converteert de gehele tekenreeks naar hoofdletters, en lower() respectievelijk in kleine letters. Gebaseerd op Lijst 1 de volgende lijst laat zien hoe u de lower() methode.

Lijst 3:

listOfPlaces = ["Berlin", "Paris", "Lausanne"]
currentCity = "lausANne"

for place in listOfPlaces:
    print (f"comparing {place} with {place.lower() == currentCity.lower()}: {currentCity}")

De output is als volgt:

$ python3 comparing-strings-case-insensitive.py
comparing Berlin with lausANne: False
comparing Paris with lausANne: False
comparing Lausanne with lausANne: True

Tekenreeksen vergelijken met reguliere expressies (RegEx)

A Regular Expression – of kortweg ‘regex’ – definieert een specifiek patroon van karakters.

Om gebruik te maken van dit mechanisme in Python importeert u het re module eerst en definieer vervolgens een specifiek patroon. Nogmaals, het volgende voorbeeld is gebaseerd op Lijst 1. Het zoekpatroon komt overeen met 'bay' en begint met een kleine letter of een hoofdletter. Precies, de volgende Python-code vindt alle strings waarin het zoekpatroon voorkomt, ongeacht op welke positie van de string: aan het begin, in het midden of aan het einde.

Lijst 4:

import re


listOfPlaces = ["Bayswater", "Table Bay", "Bejing", "Bombay"]


pattern = re.compile("[Bb]ay")

for place in listOfPlaces:
    if pattern.search(place):
        print (f"{place} matches the search pattern")

De uitvoer is als volgt en komt overeen met 'Bayswater', 'Table Bay' en 'Bombay' uit de lijst met plaatsen:

$ python3 comparing-strings-re.py
Bayswater matches the search pattern
Table Bay matches the search pattern
Bombay matches the search pattern

Vergelijkingen met meerdere regels en lijsten

Tot nu toe beperkten onze vergelijkingen zich tot slechts een paar woorden. De ... gebruiken difflib module Python biedt ook een manier om strings met meerdere regels en volledige woordenlijsten te vergelijken. De uitvoer kan worden geconfigureerd volgens verschillende formaten van diff-tools.

Het volgende voorbeeld (Lijst 5) vergelijkt twee reeksen van meerdere regels regel voor regel, en toont zowel verwijderingen als toevoegingen. Na de initialisatie van de Differ object in regel 12 wordt de vergelijking gemaakt met behulp van de compare() methode in regel 15. Het resultaat wordt afgedrukt op de standaarduitvoer:

import difflib
 


original = ["About the IIS", "", "IIS 8.5 has several improvements related", "to performance in large-scale scenarios, such", "as those used by commercial hosting providers and Microsoft's", "own cloud offerings."]


edited = ["About the IIS", "", "It has several improvements related", "to performance in large-scale scenarios."]


d = difflib.Differ()
 

diff = d.compare(original, edited)
 

print ('n'.join(diff))

Als u het script uitvoert, wordt de uitvoer gemaakt zoals hieronder weergegeven. Regels met verwijderingen worden aangegeven met - tekens, terwijl regels met toevoegingen beginnen met een + teken. Bovendien beginnen regels met wijzigingen met een vraagteken. Wijzigingen worden aangegeven met ^ borden op de overeenkomstige positie. Lijnen zonder indicator zijn nog steeds hetzelfde:

$ python comparing-strings-difflib.py
  About the IIS
  
- IIS 8.5 has several improvements related
?  ^^^^^^

+ It has several improvements related
?  ^

- to performance in large-scale scenarios, such
?                                        ^^^^^^

+ to performance in large-scale scenarios.
?                                        ^

- as those used by commercial hosting providers and Microsoft's
- own cloud offerings.

Conclusie

In dit artikel heb je verschillende manieren geleerd om strings in Python te vergelijken. We hopen dat dit overzicht je helpt bij het effectief programmeren in het leven van je ontwikkelaar.

Danksagung

De auteur wil Mandy Neumeyer bedanken voor haar steun bij het voorbereiden van het artikel.