Python - Guide pratique, aide-mémoire

Logo

Un aide mémoire, à compléter au fil du temps : traitement des données json, arguments des programmes (argparse), fichiers ini (configparser), fichiers yaml (PyYAML), requêtes HTTP (packages requests et httplib2)…

JSON

import json

loads : chargement de données JSON depuis une variable string

response_json='{"a":1, "b":2}'
json_data = json.loads(response_json)

for key in json_data:
	print("key : %s, value: %s" % (key,json_data[key]))

load : chargement de données JSON depuis un fichier

with open('json-data.json', 'r') as f:
    json_data = json.load(f)

Gestion des données mal formatées :

with open('json-data.json') as f:
	try:
		json_data = json.load(f)
	except Exception as e:
		print("Exception raised | %s " % str(e))
		exit()

dumps : retourner une chaîne de caractères JSON à partir d’un dictionnaire

response = {}
response["url"] = "sqlpac.com"
response["ostypes"] = ["mac","win"]
response["isactive"] = True

json_string = json.dumps(response)
{"url": "sqlpac.com", "ostypes": ["mac", "win"], "isactive": true}

dump : écrire des données JSON dans un fichier à partir d’un dictionnaire

with open('response.json', 'w') as f:
 json.dump(response,f,indent=4, ensure_ascii=False, sort_keys=False )
{
    "url": "sqlpac.com",
    "ostypes": [
        "mac",
        "win"
    ],
    "isactive": true
}

Les options indent, ensure_ascii, sort_keys sont également disponibles dans la méthode dumps.

argparse (parsing des arguments)

import argparse
p = argparse.ArgumentParser()
              
p.add_argument('-a','--address', help='URL', required=True)
p.add_argument("-j","--jsonauth",
					help="JSON Authentication file path",
					default="/home/sqlpac/auth.json",
					dest="jfile")
p.add_argument("-y","--year",
                      type=int,
                      default=2020,
                      help="Year")
p.add_argument("-v","--verbosity",
                      help="Verbosity",
                      action="store_true")

args = p.parse_args()
              
print(args.year)
print(args.jfile)
…

Valeurs multiples : nargs n | *

p.add_argument('-a','--address',nargs='*',help='URLs',required=True)

Les valeurs sont alors stockées dans un objet list : 

print(args.address)['url1.html', 'url2.html']

Héritage de parsers pour éviter la redondance de code :

    p1 = argparse.ArgumentParser(add_help=False)
    p1.add_argument("-a", "--address", nargs='*',
                    help="URLs to be checked")
 
    p2 = argparse.ArgumentParser(add_help=False)
    p2.add_argument("-j", "--jsonauth",
                    default="/home/sqlpac/auth.json",
                    help="JSON Authentication file path")
   
    child = argparse.ArgumentParser(parents=[p1,p2],add_help=True)
    child.add_argument("-y","--year",
                      type=int,
                      default=2020,
                      help="Year")

Dans les parsers parents, add_help est défini à False pour éviter les conflits sur l’option -h, --help.

Récupérer le nom du programme :

print(p.prog)demoarg.py

Fichiers INI (configparser)

sqlpac.ini :

[general]
dir=/home/sqlpac
logdir = ${dir}/logs
debug=false
              
[debug]
logdir = ${general:logdir}/debug
log=debug.log

read : lire un fichier ini

import configparser

cfg = configparser.ConfigParser()
cfg.read('sqlpac.ini')

sections : récupérer les sections 

sec = cfg.sections()
print(sec)
['general', 'debug']

L’objet Config ne transpose pas les types de données, le type string est systématiquement appliqué. Une conversion doit être réalisée :

vdebug = cfg['general'].getboolean('debug', False)

Dans l’exemple ci-dessus, l’interpolation étendue (extended interpolation) est nécessaire pour les évaluations de variables (cross sections) : 

import configparser
from configparser import ExtendedInterpolation

cfg = configparser.ConfigParser(interpolation=ExtendedInterpolation())
cfg.read('sqlpac.ini')

print(cfg['debug']['logdir'])
/home/sqlpac/logs/debug

Modifier les délimiteurs et préfixes de commentaires :

cfg = configparser.ConfigParser( delimiters=('=', ':', '~'),
                                 comment_prefixes=('#', ';', '@') )

write : écrire un fichier ini

import configparser
config = configparser.ConfigParser()

config.add_section('general');
config.set('general','dir','/home/sqlpac')

with open('sqlpac.ini', 'w') as cfgfile:
  config.write(cfgfile)

Fichiers YAML

sqlpac.yaml :

general:
  dir: /home/sqlpac
  logdir: /home/sqlpac/logs
  debug: false

Le ppackage PyYAML doit être installé.

load : lire un fichier YAML

import yaml

with open("sqlpac.yaml", "r") as ymlfile:
    cfg = yaml.load(ymlfile, Loader=yaml.FullLoader)

Les types de données appropriés sont appliqués par rapport à configparser

print(type(cfg['general']['debug']))
<class 'bool'>

Le type de données est forcé dans le fichier YAML :

general:
  version: !!str 5.8

dump : écrire un fichier YAML

import yaml
cfgyaml = {}

cfgyaml["general"] = {}
cfgyaml["general"]["dir"] = "/home/sqlpac"

with open("sqlpac.yaml", "w") as f:
	yaml.dump(cfgyaml, f, sort_keys=False)

sort_keys est disponible à partir de PyYAML v5.1, par défaut les clés sont triées.

Les variables ne sont pas possibles dans les fichiers YAML par rapport à configparser, en revanche les sous sections sont autorisées.

requests

get : une simple requête GET

import requests

r = requests.get('https://www.sqlpac.com/rpc.php')
  • Statut : r.status_code
  • Entêtes : r.headers
  • Résultats : r.text

json : un décodeur JSON est intégré dans le package requests

json_data = r.json()

Envoyer des paramètres GET :

q = { 'name': 'Doe', 'year': 2006 }
r = requests.get('https://www.sqlpac.com/rpc.php', params=q)

post : envoyer des paramètres POST

d = { 'name': 'Doe', 'year': 2006 }
r = requests.post('https://www.sqlpac.com/rpc.php', data=d)

Envoyer des fichiers avec la méthode POST : 

d = { 'name': 'Doe', 'year': 2006 }
f = {'file': open('1.txt', 'rb'), 'file': open('2.txt', 'rb')}
r = requests.post('https://www.sqlpac.com/rpc.php', data=d, files=f)

Utiliser verify=False pour désactiver la validation du certificat SSL :

r = requests.get('https://www.sqlpac.com/rpc.php', params=q,
                  verify=False)

Authentification basique :

import requests
from requests.auth import HTTPBasicAuth

r = requests.get('https://www.sqlpac.com/rpc.php',
                 auth=HTTPBasicAuth('<user>', '<password>'))

httplib2

request : une simple requête GET

import httplib2

http = httplib2.Http()
(headers,content) = http.request("https://www.sqlpac.com/rpc.php",
                                 method="GET")
  • Statut : headers.status
  • Entêtes : headers
  • Résultats : content

Un décodeur JSON n’est pas intégré, le package json est utilisé : 

import httplib2
import json

http = httplib2.Http()
(headers,content)= http.request("https://www.sqlpac.com/rpc.php",
                                 method="GET")

if (headers.status==200):
  json_data = json.loads(content)

Envoyer des paramètres GET (package urllib)

import httplib2
from urllib.parse import urlencode

q = { "name": "Doe", "year": 2006 }
p = urlencode(q)

http = httplib2.Http()
(headers,content)= http.request("https://www.sqlpac.com/rpc.php?" + p,
                                    method="GET")

Envoyer des paramètres POST :

import httplib2
from urllib.parse import urlencode

d = { 'name': 'Doe', 'year': 2006 }

http = httplib2.Http()
(headers,content)= http.request("https://www.sqlpac.com/rpc.php",
						method="POST",
						headers={'Content-type': 'application/x-www-form-urlencoded'},
						body=urlencode(d)
								  )

Pour désactiver la validation du certificat SSL :

http = httplib2.Http()
http.disable_ssl_certificate_validation=True

Authentification basique :

http = httplib2.Http()
http.add_credentials('<user>','<password>')