PYTHON &

DATABASES
CURS
CONECTAREA LA BAZE DE DATE MYSQL

• Interacțiunea dintre Python și MongoDB este posibilă prin intermediul pachetului MySQL
Connector.
• Se instaleaza pachetul cu pip install mysql-connector-python

Cod Python mysql.connector

MySQL database
REALIZAREA CONEXIUNII

1. Se importă pachetul mysql.connector în Python:

import mysql.connector
 
2. Se precizează conexiunea la serverul MySQL:
cnx = connection.MySQLConnection(user='scott',
password='password',
host='127.0.0.1',
database=‘clienti_daune')
REALIZAREA INTEROGĂRILOR
3. Similar cu modalitarea de interogare din pachetul cx_Oracle, interogările în mysql.connector utilizează mecanismul de
tip cursor:
cursor = cnx.cursor()

4.  Se specifică într-o variabilă de tip șir de caractere comanda SQL, inclusiv parametrii precizați prin %s:
query = "SELECT marca, model, data_vanzarii FROM t_client_daune
WHERE data_vanzarii BETWEEN %s AND %s"
data_start = datetime.date(1999, 1, 1)
data_end = datetime.date(1999, 12, 31)

5. Se execută interogarea prin intermediul cursorului:

cursor.execute(query, (data_start, data_end))
REALIZAREA INTEROGĂRILOR

6. Datele din cursor se pot încărca direct într-o listă de tupluri sau se poate parcurge cursorul în cadrul unui for:
lista = cursor.fetchall()
for rec in cursor:
print("Autoturismul:", rec)

7. Datele din listă se pot încărca într-un DataFrame Pandas:

df = pd.DataFrame(lista)

8. Închidem cursorul și conexiunea:

cursor.close()
cnx.close()
REALIZAREA OPERAȚIILOR DML
Toate comenzile SQL se pot transmite către serverul MySQL prin intermediul metodei execute a cursorului.
INSERT:
1.  Se specifică într-o variabilă de tip șir de caractere comanda SQL care va fi executată, inclusiv parametrii sub
forma %s:
sql = "INSERT INTO T_clienti_leasing (id_client, nume_client, profesia) VALUES
(%s, %s, %s) "
params=(123456, "Ion Popa", "Inginer")
2. Se execută interogarea prin intermediul cursorului:
cursor.execute(sql,params)
3. Tranzacția se poate finaliza cu commit realizată la nivelul conexiunii:
cnx.commit()
4. Se poate afișa numărul de înregistrări afectate de tranzacție:
print(cursor.rowcount, "inregistrari inserate")
5. Închidem cursorul și conexiunea:
cursor.close()
cnx.close()
REALIZAREA OPERAȚIILOR DML
UPDATE:
1.  Se specifică într-o variabilă de tip șir de caractere comanda SQL care va fi executată, inclusiv parametrii
sub forma %s:
sql = "UPDATE T_CLIENTI_LEASING SET SUMA_SOLICITATA= 10000
WHERE NUME_CLIENT = %s "
params=("Ion Popa")
2. Se execută interogarea prin intermediul cursorului:
cursor.execute(sql,params)
3. Tranzacția se poate finaliza cu commit realizată la nivelul conexiunii:
cnx.commit()
4. Se poate afișa numărul de înregistrări afectate de tranzacție:
print(cursor.rowcount, " inregistrari actualizate")
5. Închidem cursorul și conexiunea:
cursor.close()
cnx.close()
REALIZAREA OPERAȚIILOR DML
DELETE:
1.  Se specifică într-o variabilă de tip șir de caractere comanda SQL care va fi executată, inclusiv
parametrii sub forma %s:
sql = “DELETE FROM T_CLIENTI_LEASING WHERE NUME_CLIENT = %s "
params=("Ion Popa")
2. Se execută interogarea prin intermediul cursorului:
cursor.execute(sql,params)
3. Tranzacția se poate finaliza cu commit realizată la nivelul conexiunii:
cnx.commit()
4. Se poate afișa numărul de înregistrări afectate de tranzacție:
print(cursor.rowcount, "inregistrari sterse")
5. Închidem cursorul și conexiunea:
cursor.close()
cnx.close()
CONECTAREA LA BAZE DE DATE NOSQL
MONGODB

• Interacțiunea dintre Python și MongoDB este posibilă prin intermediul pachetului pymongo
care conține metode pentru accesul la bazele de date și colecțiile stocate în MongoDB.
• Se instaleaza pachetul cu pip install pymongo

Cod Python Pymongo

MongoDB
collections
REALIZAREA CONEXIUNII

1. Se importă pachetul pymongo în Python:

import pymongo
 
2. Se precizează conexiunea la serverul MongoDB:
connection =
pymongo.MongoClient("mongodb://37.120.249.57:27017/")

3. Opțional se pot afișa bazele de date disponibile:

print(connection.list_database_names())

4. Se precizează baza de date care se va accesa:

db = connection["NUME_DATABASE"]
REALIZAREA CONEXIUNII

5. Opțional se pot afișa colecțiile de date disponibile:

 print(db.list_collection_names())
 
6. Se precizează colecția de documente care urmează să fie accesată:
collection = db["NUME_COLECTIE"]

7. Se formează parametrii pentru regăsirea datelor și returnarea acestora într-un cursor:

projection={"_id":0,
"CAMP1":1,
"CAMP2":1,
……… }
sort=[("CAMP1", 1)]
REALIZAREA INTEROGĂRILOR

8. Se returnează datele într-o variabilă de tip cursor:

cursor=collection.find({},projection=projection, sort=sort)

 9. Datele din cursor se pot încărca direct într-o listă de dicționare:
 set_clienti=list(cursor)
Sau se poate parcurge cursorul în cadrul unui for:
for rec in cursor:
print("Documentul:", rec)
10. Închidem cursorul:
cursor.close()
Metodele cursorului din pachetul PyMongo poate fi consultată aici:
https://api.mongodb.com/python/current/api/pymongo/cursor.html
INTEROGAREA DOCUMENTELOR IN MONGODB

• Regasirea datelor în Mongo DB se realizează prin metodele find() în care se precizează

condițiile de regăsire și projection() în care sunt precizate atributele care vor fi afișate. Pentru
ordonarea datelor este utilizată metoda sort().
• Parametrii metodei projection() sunt atributele (câmpurile) care vor fi afișate urmate de :0 în
cazul în care dorim să nu afișam câmpul sau :1 în cazul în care dorim ca acel câmp să fie inclus
în vizualizare. Doar atributul _id poate fi exclus în cazul în care avem câmpuri precizate cu
valoarea :1.
• Pentru a afișa anumite câmpuri, acestea se pot specifica și în metoda find(), după criteriul de
regăsire.
INTEROGAREA DOCUMENTELOR IN MONGODB

• Agregările sunt procesate sub forma unui flux de tip pipeline implementat prin metoda aggregate() în care o listă
de operatori / filtre sunt aplicate datelor.
• Fluxul de prelucrare conține etapele de filtrare ($match: {conditii pentru câmpuri}), grupare ($group:
{ _id: { key1: "$Alias1", key2: "$Alias2" }) și ordonare ($sort: { Alias1: -1,
Alias2:1 }), iar în cazul în care se restricționează documentele din grupurile formate (similar cu clauza HAVING
din SQL) se utilizează etapa de filtrare pe grupuri ($match: {conditii pentru grupuri}):
db.col.aggregate( [
{ $match: { conditii pentru keys} },
{ $group: { _id: { key1: "$Alias1", key2: "$Alias2" },
count: { $sum: 1 }, suma:{$sum:key3},medie:{$avg:key4} } },
{ $match: { conditii pentru grup} },
{ $project: { _id: 0,
key1: "$_id.Alias1",
key2: "$_id.Alias2",
count: 1,………..},
{ $sort: { Alias1: -1, Alias2:1 }} ] )
 REALIZAREA INTEROGĂRILOR
Exemplul 1. Conectarea la MongoDB și afișarea documentelor din colecția clienti_daune.
Se returnează doar câmpurile: MARCA, MODEL, REGIUNEPRODUCATOR , TARAPRODUCATOR și VALOARE_DAUNA.
Documentele vor fi ordonate în funcție de MARCA. Nu se vor încărca documentele cu valori lipsă pentru daune.

import pymongo
conn = pymongo.MongoClient("mongodb://37.120.249.57:27017/")
print(conn.list_database_names())
db = conn["daune_leasing"]
print(db.list_collection_names())
collection = db["clienti_daune"]
projection={"_id":0,
"TARAPRODUCATOR":1,
"REGIUNEPRODUCATOR":1,
"MARCA":1,
"MODEL":1,
"VALOARE_DAUNA":1
}
sort=[("MARCA", 1)]
cursor=collection.find({},projection=projection, sort=sort)
#lista set_clienti este o lista de dictionare care va contine campurile selectate
set_clienti=[]
for r in cursor:
if str(r['VALOARE_DAUNA'])!='nan':
set_clienti.append(r)
print (set_clienti)
cursor.close()
 REALIZAREA INTEROGĂRILOR
• Pentru analiza datelor din MongoDB se poate utiliza pachetul pandas.
• Conexiunea cu MongoDB se gestionează de către pachetul PyMongo, se parcurg pașii 1..8 de mai
sus, iar datele din cursor se încarcă într-un DataFrame Pandas astfel:
df = pd.DataFrame.from_dict(list(cursor))
 REALIZAREA INTEROGĂRILOR
Exemplul 2: Să se încarce într-un DataFrame Pandas documentele din colecția clienti_daune care
conțin autoturismele fabricate înainte de 2010 și care au componenta BATTERY defectă:
import pymongo
import pandas as pd
from pprint import pprint
conn = pymongo.MongoClient("mongodb://37.120.249.57:27017/")
db = conn["daune_leasing"]
collection = db["clienti_daune"]
projection = {"_id": 0,
"AN_FABRICATIE": 1,
"MARCA": 1,
"COMPONENTA": 1,
"PRET_MANOPERA": 1
}
sort = [("MARCA", 1)]
cursor = collection.find({"COMPONENTA": "BATTERY",
"AN_FABRICATIE": {'$lt': 2010}}, projection=projection,
sort=sort)

df = pd.DataFrame.from_dict(list(cursor))
cursor.close()
pprint (df)
 REALIZAREA WEB API IN PYTHON - FLASK
• Flask este un framework web pentru Python, ceea ce înseamnă că oferă funcționalitate pentru
construirea aplicațiilor web, inclusiv gestionarea cererilor HTTP și a șabloanelor de vizualizare.
• Interfețele web API vor fi accesate pe o adresă web de tipul http://127.0.0.1:5000.
• Flask mapează cererile HTTP pentru aplicațiile/funcțiile scrise în Python.
• Când se realizează conexiunea la serverul Flask se verifică dacă există o potrivire între calea
furnizată și o funcție definită și afișează rezultatul returnat în browser.
• Procesul de mapare a adreselor URL către funcții se numește rutare.
 REALIZAREA WEB API IN PYTHON - FLASK
Elemente utilizate:
• import flask - Importă pachetul Flask în cadrul aplicației scrise în Python;
• app = flask.Flask (__ nume__) - creează obiectul de tip Flask, care conține date despre aplicație
și, de asemenea, metodele pentru realizarea anumitor acțiuni.
• app.config ["DEBUG"] = True - pornește depanatorul, în cazul în care codul este incorect, se va
afișa o eroare când se accesează aplicația. În caz contrar, în browser se va afișa un mesaj generic,
cum ar fi Bad Gateway, atunci când există o problemă în cod.
• Instrucțiunea @ app.route ('/', metode = ['GET']) permite Flask să mapeze aplicația la calea /.
Metoda ['GET'] permite Flask să știe ce tip de solicitări HTTP sunt permise. Multe aplicații web
utilizează atât cereri GET (pentru a returna date din aplicație/BD către utilizator) cât și solicitări
POST (pentru a trimite date de la un utilizator către aplicație/BD).
 REALIZAREA WEB API IN PYTHON - FLASK
• Instrucțiunile:
def home():
return '''<h1>Denumire aplicație</h1>
<p>API pentru …………</p>'''
Permit afișarea în pagina principală unui titlul și mesaj explicativ referitor la aplicație.
• Instrucțiunile:
@app.errorhandler(404)
def page_not_found(e):
return "<h1>404</h1><p>The resource could not be found.</p>", 404
permit afișarea unui mesaj de eroare pe pagina web în cazul în care adresa este invalidă sau
parametrii nu sunt precizați corect.
 REALIZAREA WEB API IN PYTHON - FLASK
Instrucțiunile:
@app.route('/api/v1/resources/functiePython', methods=['GET'])
def functie Pyhon():
#cod sursă Python
return
Permit rutarea din pagina web către funcția implementată în Python utilizând calea
http://127.0.0.1:5000/api/v1/resources/functiePython
Parametrii de intrare se pot transmite sub forma unei liste:
http://127.0.0.1:5000/api/v1/resources/functiePython?param1=val1&param2=val2&param3=val3
 REALIZAREA WEB API IN PYTHON - FLASK
app.run () – apelează metoda care rulează serverul de aplicații și permite accesul din browser la
aplicația realizată. Implicit serverul va rula pe adresa http://127.0.0.1:5000, însă se poate specifica și
o altă adresă și port, de exemplu: app.run(host= '37.120.250.20', port=5003)
return jsonify(colection) – returnează în browser sub formă de fișier .json o colecție de date din
Python
• După dezvoltarea codului Python și stabilirea parametrilor pentru rutare și rulare pentru serverul
Flask, codul sursă sub formă de fișier cu extensia .py este încărcat pe serverul de aplicații într-un
director de unde se rulează și rămane activ pentru apelul din alte interfețele
REALIZAREA WEB API IN PYTHON - FLASK
import flask
from flask import request, jsonify
#http://127.0.0.1:5000/api/v1/resources/books/all
app = flask.Flask(__name__) #http://127.0.0.1:5000/api/v1/resources/books?id=2
app.config["DEBUG"] = True

# Create some test data for our catalog in the form of a list of dictionaries.
books = [
{'id': 0,
'title': 'A Fire Upon the Deep',
'author': 'Vernor Vinge',
'first_sentence': 'The coldsleep itself was dreamless.',
'year_published': '1992'},
{'id': 1,
'title': 'The Ones Who Walk Away From Omelas',
'author': 'Ursula K. Le Guin',
'first_sentence': 'With a clamor of bells that set the swallows soaring, the Festival of Summer came to the city Omelas, bright-
towered by the sea.',
'published': '1973'},
{'id': 2,
'title': 'Dhalgren',
'author': 'Samuel R. Delany',
'first_sentence': 'to wound the autumnal city.',
'published': '1975'}
]

@app.route('/', methods=['GET'])
def home():
return '''<h1>Distant Reading Archive</h1>
<p>A prototype API for distant reading of science fiction novels.</p>'''
# A route to return all of the available entries in our catalog.
@app.route('/api/v1/resources/books/all', methods=['GET'])
def api_all():
return jsonify(books)

@app.route('/api/v1/resources/books', methods=['GET'])
def api_id():
# Check if an the params were provided as part of the URL.
if 'id' in request.args:
id = int(request.args['id'])
else:
return "Error: No id field provided. Please specify an id."
# Create an empty list for our results
results = []
for book in books:
if book['id'] == id:
results.append(book)

# Use the jsonify function from Flask to convert our list of

# Python dictionaries to the JSON format.
return jsonify(results)

app.run()
 • MySQL Connector documentation
https://dev.mysql.com/doc/connector-python/en/connector-python-e
SURSE xample-connecting.html

BIBLIOGRAFICE
• PyMongo 3.9.0 Documentation
https://api.mongodb.com/python/current/