Phenquestions
We kunnen communiceren met databases met behulp van elke programmeertaal, of we kunnen een softwareprogramma gebruiken waarmee we kunnen communiceren met de database met behulp van een GUI. In dit artikel bespreken we databases en laten we zien hoe u ermee kunt communiceren met behulp van de programmeertaal Python.
Relationele databases (SQL)
Relationele databases (SQL) verschillen qua schema van niet-relationele databases (NoSQL). Een schema is een sjabloon die de structuur definieert van de gegevens die u gaat opslaan. In relationele databases maken we tabellen om gegevens op te slaan. Het schema van een tabel wordt gedefinieerd wanneer de tabel wordt gemaakt. Als we bijvoorbeeld gegevens over studenten willen opslaan in een relationele database, zullen we een tabel met studenten maken en het schema van de tabel definiëren, dat de naam, het registratienummer, het cijfer, enz. van elke student. Nadat we het schema hebben gemaakt, slaan we de gegevens op in de rijen van de tabel. Het is belangrijk op te merken dat we geen gegevens kunnen opslaan die niet in het schema zijn gedefinieerd. In dit voorbeeld kan het cijfer dat een student voor een examen heeft behaald niet in de tabel worden opgeslagen omdat we geen kolom voor deze gegevens in het schema hebben gedefinieerd.
De volgende lijst bevat enkele populaire relationele databases:
- MariaDB
- MySQL
- SQL-server
- PostgreSQL
- Orakel
Niet-relationele databases (NoSQL)
Zoals hierboven besproken, hebben niet-relationele databases geen gedefinieerd schema. Niet-relationele databases hebben collecties in plaats van tabellen, en deze collecties bevatten documenten die gelijk zijn aan de rijen in een relationele database. Als we bijvoorbeeld een niet-relationele database willen maken om studentgegevens op te slaan, kunnen we een verzameling gebruikers maken en in deze verzameling slaan we een document op voor elke student. Deze documenten hebben geen gedefinieerd schema en je kunt voor elke student alles opslaan wat je wilt.
CRUD-bewerkingen uitvoeren in MySQL
Nu laten we u zien hoe u met MySQL kunt communiceren met Python.
MySQL-stuurprogramma voor Python installeren
Om te communiceren met MySQL met behulp van Python, moeten we eerst het MySQL-stuurprogramma in Python installeren.
[email protected]:~$ sudo pip3 install mysql-connector-pythonof
[email protected]:~$ sudo pip install mysql-connector-pythonEen database maken
Voordat we een database maken, moeten we verbinding maken met de MySQL-server met behulp van Python. de mysql.connector-module biedt de methode connect() om te helpen een verbinding tot stand te brengen met MySQL met behulp van Python.
>>> mysql importeren.verbindingsstuk// Vervang door uw eigen IP- en serverreferenties
>>> sql = mysql.verbindingsstuk.aansluiten(
… host='localhost',
… gebruiker='root',
… wachtwoord='12345'
…)
>>> afdrukken (sql)
Dit bericht laat zien dat we een verbinding hebben gemaakt met een MySQL-database met behulp van Python. Nu zullen we een SQL-query uitvoeren op de MySQL-server met behulp van de methode execute() uit de mysql.aansluitmodule.
>>> cursor = sql.cursor()>>> query = 'MAAK DATABASE demo_db'
>>> cursor.uitvoeren (vraag)
De bovenstaande code maakt een database met de naam demo_db in MySQL.
Een tabel maken
Nu we een database hebben gemaakt, gaan we een nieuwe tabel maken met de naam studenten. Om een tabel te maken, moeten we verbinding maken met de database.
>>> sql_db = mysql.verbindingsstuk.aansluiten(… host='lokale host',
… gebruiker='root',
… wachtwoord='12345',
… database='demo_db'
…)
Nadat we verbinding hebben gemaakt met de database, gebruiken we de methode execute() om een SQL-query uit te voeren om een tabel met een schema te maken.
>>> query = "CREATE TABLE studenten(naam VARCHAR(64), id INT, cijfer INT, dob DATE)";>>> cursor.uitvoeren (vraag);
De bovenstaande opdracht maakt een tabel met de naam studenten in de demo_db-database; we kunnen alleen een naam, id, graad en geboortedatum in de tabel invoegen, zoals gedefinieerd in schema.
Rijen invoegen in een tabel
Nu we een tabel hebben gemaakt, zullen we een leerling in deze tabel invoegen. We zullen een query maken en vervolgens de methode execute() gebruiken om de query uit te voeren op de MySQL-server met behulp van Python.
>>> query = 'INSERT INTO students(name, id, grade, dob) VALUES(“John”, 1, 3, “2020-7-04”)'>>> cursor.uitvoeren (vraag)
>>> sql_db.plegen()
Deze query voegt een leerling toe met de gegevens die in de query zijn gedefinieerd in de tabel. We kunnen op dezelfde manier extra studenten aan de tafel toevoegen.
OPMERKING: Wijzigingen worden alleen toegepast op de database als u sql_db uitvoert.commit() na het toepassen van wijzigingen.
Rijen selecteren uit een tabel
De SELECT-instructie in MySQL wordt gebruikt om gegevens uit een tabel te retourneren. We zullen de methode execute() gebruiken om een query uit te voeren, en dan zullen we de methode fetchall() gebruiken om een lijst van alle studenten te krijgen. Vervolgens kunnen we een for-lus gebruiken om alle studenten weer te geven
>>> query = 'SELECTEER * VAN studenten'>>> cursor.uitvoeren (vraag)
>>> resultaat = cursor.ophalen()
>>> voor x in resultaat:
… afdruk(x)
('Jan', 1, 3, datetime.datum(2020, 7, 4))
We kunnen zien dat er alleen gegevens voor een enkele student worden geretourneerd, omdat we slechts één student in de tabel hebben. We kunnen de WHERE-instructie in MySQL gebruiken met de SELECT-instructie om beperkingen op te geven. Als we bijvoorbeeld de studenten alleen in groep 4 willen retourneren, kunnen we de volgende query gebruiken:
>>> query = 'SELECTEER * VAN studenten WHERE grade = 4'>>> cursor.uitvoeren (vraag)
>>> resultaat = cursor.ophalen()
>>> voor x in resultaat:
… afdruk(x)
De bovenstaande code haalt alleen de studenten uit groep 4.
Een rij bijwerken
In deze sectie laten we u zien hoe u de studentgegevens in een MySQL-tabel kunt bijwerken met Python. We zullen het UPDATE-statement gebruiken met de WHERE- en SET-statements in MySQL om de gegevens van specifieke studenten bij te werken. De WHERE-instructie wordt gebruikt om te bepalen welke rijen worden bijgewerkt en de SET-instructie wordt gebruikt om de waarden te definiëren die voor de update worden gebruikt.
>>> query = 'UPDATE studenten SET name="Mark" WHERE id = 4'>>> cursor.uitvoeren (vraag)
>>> sql_db.plegen()
Nu zullen we proberen de leerlinggegevens uit de tabel te lezen met behulp van de SELECT-instructie.
>>> query = 'SELECTEER * VAN studenten WHERE id=4'>>> cursor.uitvoeren (vraag)
>>> voor x in cursor:
… afdruk(x)
('Mark', 4, 4, datumtijd.datum(2020, 7, 15))
Nu kunnen we zien dat de naam van de student met id 4 is veranderd in Mark.
Een rij verwijderen
We kunnen een rij uit de tabel verwijderen door de DELETE-instructie in MySQL toe te passen met Python. We gebruiken een DELETE-instructie met een WHERE-instructie om specifieke studenten uit de tabel te verwijderen.
>>> query = 'VERWIJDEREN VAN studenten WHERE id=2'>>> cursor.uitvoeren (vraag)
>>> sql_db.plegen()
Nu kunnen we alle studenten uit de tabel retourneren met behulp van de SELECT-instructie.
>>> query = 'SELECTEER * VAN studenten'>>> cursor.uitvoeren (vraag)
>>> voor x in cursor:
… afdruk(x)
('Jan', 1, 3, datetime.datum(2020, 7, 4))
('Jan', 3, 3, datumtijd.datum(2020, 7, 8))
('Mark', 4, 4, datumtijd.datum(2020, 7, 15))
We kunnen zien dat de tabel geen student met een id van 2 bevat, omdat we de student van de tafel hebben verwijderd.
Een tafel laten vallen
de mysql.connectormodule kan ook worden gebruikt om een tafel te laten vallen. We kunnen een DROP-statement in MySQL uitvoeren met behulp van de methode execute()).
>>> cursor = sql_db.cursor()>>> query = 'DROP TABLE studenten'
>>> cursor.uitvoeren (vraag)
De bovenstaande code verwijdert de tabel met de naam studenten wanneer deze wordt uitgevoerd in Python.
Dat besluit onze bespreking van SQL-databases. We hebben u laten zien hoe u verschillende query's kunt toepassen op de MySQL-database met behulp van Python. Vervolgens zullen we CRUD-bewerkingen toepassen op een NoSQL-database genaamd MongoDB
CRUD-bewerkingen uitvoeren in MongoDB
Om te communiceren met MongoDB met behulp van Python, moeten we eerst pymongo installeren, een MongoDB-stuurprogramma voor Python.
[e-mail beveiligd]:~$ sudo pip install pymongoof
[e-mail beveiligd]:~$ sudo pip3 install pymongoEen database maken
We kunnen verbinding maken met MongoDB met behulp van de MongoClient()-methode van de pymongo-module in MongoDB. Voordat we acties uitvoeren, moeten we verbinding maken met de MongoDB-database.
>>> import pymongo>>> klant = pymongo.MongoClient('mongodb://localhost:27017/')
Nadat we verbinding hebben gemaakt met de datacase, kunnen we de volgende regel uitvoeren om een nieuwe database te maken met de naam demo_db.
>>> db = klant['demo_db']Als de database al bestaat, wordt deze opdracht genegeerd.
Een collectie maken
Nu we een database hebben gemaakt, zullen we een verzameling met de naam studenten maken in de database met de naam.
>>> import pymongo>>> klant = pymongo.MongoClient('mongodb://localhost:27017/')
>>> db = klant['demo_db']
>>> col = db['studenten']
OPMERKING: MongoDB maakt geen verzameling totdat u er gegevens in invoert. Daarom, als u probeert toegang te krijgen tot de verzameling na het uitvoeren van de bovenstaande code, zult u ontdekken dat er niets in de database staat.
Unlined MySQL, we hoeven geen schema te definiëren wanneer we een nieuwe collectie maken, aangezien MongoDB een niet-relationele database is.
Een document invoegen
Nadat we een verzameling hebben gemaakt, kunnen we een document in de verzameling invoegen. Eerst moeten we een woordenboek definiëren, en dan kunnen we de methode insert_one() gebruiken om de gegevens die in het woordenboek zijn gedefinieerd in de verzameling in te voegen.
OPMERKING: MongoDB maakt automatisch een unieke '_id' aan voor elk document; daarom hoeven we geen id . op te geven.
>>> gegevens =… "naam": "Jan",
… "cijfer": 3,
… "dob": "2020-04-03"
…
>>> resultaat = col.insert_one(gegevens)
In het bovenstaande document hebben we naam, cijfer en dob . ingevoegd. Nu zullen we een document invoegen in de studentencollectie met een veld voor leeftijd.
>>> gegevens =… "naam" : "Mark",
… "graad 4,
… "dob": "2020-04-09",
… "leeftijd" : 8
…
>>> resultaat = col.insert_one(gegevens)
We kunnen zien dat dit commando geen foutmelding geeft. Omdat MongoDB een niet-relationele database is, kunnen we alle gewenste informatie aan het document toevoegen.
Documenten ophalen
In deze sectie zullen we de methodes find() en find_one() gebruiken om gegevens uit de database te halen. De methode find() heeft twee argumenten: de eerste wordt gebruikt om documenten te filteren en de tweede wordt gebruikt om de velden te definiëren van het document dat we willen retourneren. Als we bijvoorbeeld de id van 'John' willen krijgen, kunnen we de volgende query uitvoeren:
>>> resultaat = col.find("name": "John", "_id": 1)>>> voor x in resultaat:
… afdruk(x)
'_id': ObjectId('5f8f0514cb12c01f7420656e')
Als alternatief kunnen we alle documenten uit de collectie halen door de volgende query te gebruiken:
>>> resultaat = col.vind()>>> voor x in resultaat:
… afdruk(x)
'_id': ObjectId('5f8f0514cb12c01f7420656e'), 'name': 'John', 'grade': 3, 'dob': '2020-04-03'
'_id': ObjectId('5f8f061ccb12c01f7420656f'), 'name': 'Mark', 'grade': 4, 'dob': '2020-04-09', 'age': 8
Documenten bijwerken
De pymongo-module biedt de methoden update_one() en update_many() voor het bijwerken van de documenten in een verzameling. Beide methoden hebben twee argumenten: de eerste definieert welk document moet worden gewijzigd en de tweede definieert de nieuwe waarden. Nu gaan we het cijfer van de leerling 'Mark' veranderen.
>>> zoekopdracht = "naam": "Mark">>> waarde = "$set": "grade": 5
>>> kleur.update_one(query, waarde)
>>> voor x in kleur.vind():
… afdruk(x)
'_id': ObjectId('5f8f0514cb12c01f7420656e'), 'name': 'John', 'grade': 3, 'dob': '2020-04-03'
'_id': ObjectId('5f8f061ccb12c01f7420656f'), 'name': 'Mark', 'grade': 5, 'dob': '2020-04-09', 'age': 8
Een document verwijderen
De pymongo-module in Python heeft twee methoden, namelijk.e., delete_one() en delete_many(), voor het verwijderen van documenten. Beide methoden hebben een argument dat het te verwijderen document selecteert. Met de volgende code verwijderen we een leerling met de naam 'John'.
>>> zoekopdracht = "naam": "Jan">>> kleur.delete_one(query)
>>> voor x in kleur.vind():
… afdruk(x)
'_id': ObjectId('5f8f061ccb12c01f7420656f'), 'name': 'Mark', 'id': 2, 'grade': 5, 'dob': '2020-04-09', 'age': 8
Een verzameling laten vallen
We kunnen een verzameling in MongoDB neerzetten met behulp van de methode drop() van de pymongo-module in Python. Eerst moeten we verbinding maken met de database; dan selecteren we de database die de collectie bevat die we willen verwijderen. Nadat we de verzameling uit de database hebben geselecteerd, kunnen we de verzameling verwijderen met de methode drop()). De volgende code zal studenten laten vallen:.
>>> import pymongo>>> klant = pymongo.MongoClient('mongodb://localhost:27017/')
>>> db = klant['demo_db']
>>> col = db['studenten']
>>> kleur.laten vallen()
Conclusie
Kennis van databases is essentieel als je een webapplicatie wilt maken. Bijna elke programmeertaal heeft frameworks en bibliotheken voor backend webontwikkeling. Python kan worden gebruikt in backend-webontwikkeling, en dus kunnen we communiceren met databases met behulp van Python terwijl we werken met Python-backendframeworks. In dit artikel hebben we u laten zien hoe u kunt communiceren met MongoDB- en MySQL-databases met behulp van eenvoudige CRUD-bewerkingen die zijn geschreven in Python.
