Archives de catégorie : Python

[Python] : comment requêter une base mysql avec mysql.connector ?

Mysql Connector est le module le plus répandu pour utiliser une base de données mysql à partir de python. Il est relativement facile à utiliser. Nous aurons l’occasion de voir dans d’autres articles des manipulations plus complexes mais il faut bien commencer par… le commencement.

Comment réaliser un simple SELECT et afficher son résultat en Python ? voici comment faire si vous êtes débutant.

import mysql.connector

madatabase = mysql.connector.connect(
  host="localhost",
  user="nom_utilisateur",
  passwd="mon_password",
  database="mabase"
)

session = madatabase.cursor()
sql = "SELECT * FROM matable;"
session.execute(sql)

resultat = session.fetchall()

for x in resultat:
  print(x)

session.close()


Donc quelles commandes avons nous passé ?

  • import du module
  • création d’une instance madatabase avec les paramètres de connexion. C’est tout à fait classique on retrouve cela avec de nombreux modules de moteurs de bases de données
  • ouverture d’une connexionavec l’instanciation de la classe cursor
  • la variable sql contient la requête à passer
  • on lance la requête avec notre variable
  • on récupère tous les résultats (sous forme de liste)
  • il ne reste plus qu’à parcourir la liste
  • et on oublie pas de dire au revoir et merci au serveur en fermant la session

Vous pouvez d’ores et déjà retrouver plus d’infos en ligne sur le site mysql et sa rubrique dédiée à ce module Python.

[Python] : comment charger des datas en base de données mysql avec mysql.connector ?

Revenons à nos pythons. Objectif du jour faire découvrir comment charger des données dans une base mysql à partir du module mysql.connector ?

Extrêmement facile. Vous me direz c’est normal car c’est le but des modules de python.

Premier cas on va chercher une ligne simple :

# import du module
import mysql.connector

# paramètres de connexion à la base
mabase = mysql.connector.connect(
  host="localhost",
  user="monutilisateurdb",
  passwd="motdepassedb",
  database="madatabase"
)

cursor = mabase.cursor()

sql = "INSERT INTO matable (id, valeur) VALUES (%s, %s)"
data = [("1", "Xavki"),("2", "Pierre"),("3", "Jacques"),("4", "Paul")]
cursor.executemany(sql, data)

mabase.commit()

Donc là on vient d’inséré une ligne. Mais bon on veut en insérer plusieur voir mieux insérer une liste. Alors il faut utiliser « executemany » :

# import du module
import mysql.connector

# paramètres de connexion à la base
mabase = mysql.connector.connect(
  host="localhost",
  user="monutilisateurdb",
  passwd="motdepassedb",
  database="madatabase"
)

cursor = mabase.cursor()

sql = "INSERT INTO matable (id, valeur) VALUES (%s, %s)"
data = ("1", "Xavki")
cursor.execute(sql, data)

mabase.commit()
print(cursor.rowcount, " insérées") 

[Python] : comment inverser un string ou une phrase (ou une liste plus généralement) ?

C’est bref mais efficace avec python : comment inverser une liste ? ou une phrase ? Il suffit de savoir manipuler les listes et parcourir cette liste à l’envers. C’est quelque chose que doivent savoir faire les débutants.

Il existe toutefois 2 méthodes.

La première c’est d’utiliser les plage d’index et de partir par la fin comme ceci :

>>> text="Salut tout le monde"
>>> text[::-1]
'ednom el tuot tulaS'

Terriblement efficace.

Sinon il y a la méthode par les méthodes lol avec reversed qui s’applique aux listes.

>>> text="Salut tout le monde"
>>> "".join(reversed(text))
'ednom el tuot tulaS'

N’hésitez pas à partager en commentaires vos astuces !

[Ansible] : lister les variables de rôles non documentées dans le README.md

Les rôles de ansible sont plus ou moins faciles à utiliser. Un des principaux facteurs limitants, c’est la documentation du README. Du coup j’ai créé un petit script pour lister les variables de vos rôles et ensuite vérifier si ces variables sont bien documentées dans le README.md (si vous avez d’autres idées n’hésitez pas).

#!/usr/bin/python3


# coding: utf8



import re
import os

def list_variables (pattern, dir):
    
  variables=[]
    
  r = re.compile(pattern)
    
  for parent, dnames, fnames in os.walk(dir):
 
       for fname in fnames:

            filename = os.path.join(parent, fname)

            if os.path.isfile(filename):

                with open(filename,encoding="latin-1") as f:

                    for line in f:

                        if r.search(line):

                          reg=r"pattern"

                          for item in re.findall(r''+pattern+'',line):

                            if item not in variables:

                              variables.append(item)

  return variables



# lister les roles

def list_roles (dir):

        roles=[]

        regexp = re.compile(r'.*\/roles\/[a-z0-1_-]+$')

        for dirname, dirnames, filenames in os.walk('.'):

                for subdirname in dirnames:

                        rep=os.path.join(dirname, subdirname)

                        if regexp.search(rep):

                                roles.append(rep)

        return roles



# avec la fonction grep on liste toutes les variables contenant un _


for role in list_roles("."):

    r = re.compile('[.]?roles/(.*)')

    match = r.search(role)

    print("")

    print("#################################################################")

    print("         Analyse du role : "+ match.group(1))

    print("#################################################################")
    compteur=0

    list_var=list_variables("\{\{\s?([a-z]+[_]+[a-z_]+)\s?\}\}",role)

    for variable in list_var:

        compteur+=1

        with open(roles+"/README.md",encoding="latin-1") as f:

            concaten=""

            for line in f:

                concaten+=line

            if not re.search(variable,concaten):

                print("Variable à éditer :"+variable)

    print(" = "+str(compteur)+" variable(s) analysé(es)")

Explications :

  •  une fonction qui liste les variables ansible :
    • on parcourt les directories (à l’aide du module OS de python)
    • et avec une regex on applique un pattern pour retrouver ce qui ressemble à une variable ({{ variable }}
    • enfin on met tout cela dans un tableau bien propre
  • une fonction qui liste les rôles :
    • idem on parcourt les directories et on cherche les répertoires contenus dans « roles »
    • à l’aide d’une regex on nettoie le nom du rôle
  • Pour finir on orchestre tout cela :
    • on boucle sur la liste des variables
    • on ouvre le README.md que l’on place dans une variable simple(on concatène les lignes)
    • et on y cherche la variable
    • si elle n’est pas dedans on affiche qu’elle est à éditer
    • et pour finir on affiche à la fin de chaque rôle le nombre de variables analysées.

Si vous voyez d’autres scripts de ce genre qui pourrait être utiles indiquez le en commentaire j’y jeterez un coup d’oeil.