Développement Web Fullstack

A quoi servent les sockets?

Les sockets vous permettent d’ouvrir une liaison continue entre le serveur et le client. A la différence d’une requête AJAX, qui est l’équivalent d’un chargement de page HTTP, qui s’arrête une fois les informations téléchargées, le socket ouvre un stream continu. Cela évite les limitations des requêtes AJAX, comme par exemple la limitation du nombre de requêtes par minutes par exemple.

Si vous voulez connaitre un cours de bourse en temps réel, hors de question d’utiliser des requêtes AJAX, car vous allez vous faire blacklister.

Installer la librairie websocket-client

Il vous faut installer la librairie websocket-client (attention il y a une autre librairie qui s’appelle websocket, ce n’est pas celle là)

pip install websocket-client

Le script:

import websocket,json,os
def on_message(ws, message):
    """ convert string to dictionary"""
    message = json.loads(message)
    clear = lambda: os.system('cls')
    clear()
    print(message)
    print(" ",message['data'][0]['p'],flush=True,end="\r")


def on_error(ws, error):
    print(error)

def on_close(ws, close_status_code, close_msg):
    print("### closed ###")

def on_open(ws):
    ws.send('{"method":"SUBSCRIBE","params":["btcusdt@aggTrade","btcusdt@depth"],"id":1}')

if __name__ == "__main__":
    websocket.enableTrace(False)
    ws = websocket.WebSocketApp(f"wss://stream.binance.com:9443/ws/bnbbtcopen@depth",
                              on_open=on_open,
                              on_message=on_message,
                              on_error=on_error,
                              on_close=on_close)
    ws.on_open = on_open
    ws.run_forever()

Lien vers la documentation du service websocket de Binance:

Alors que ça marchait très bien sous PyCharm…

Imaginons que vous ayez un programme utilisant une librairie externe, par exemple Beautifulsoup, ce dernier étant une librairie externe, donc il faut l’importer avec la commande :

pip install beautifulsoup4

Sous PyCharm, la librairie sera installée dans la section External Librairies, dans la barre latérale Project. Mais le véritable répertoire (sous Windows) sera :

C:\Users\mon_user\PycharmProjects\nom_projet\venv\Lib\site-packages

Remplacez mon_user et nom_projet par vos données propres.

Ainsi lorsque vous exécutez un programme en ligne de commande, et qu’il vous dit « Module Not Found …bs4 » c’est que l’exécutable Python n’arrive pas à le trouver. Il faut créer la variable PYTHONPATH.

Pour ce faire (Windows) dans la boite de recherche de Windows (Cortana) tapez PATH, vous accédez aux variables d’environnement. Ajoutez la nouvelle variable PYTHONPATH puis ajoutez le chemin cité plus haut. MAintenant vous pouvez lancer votre programme en ligne de commande.

Lister les valeurs des chemins d’inclusion

import sys
print(sys.path)

Ce programme va vous afficher tous les chemins qui sont tenus compte pour la recherche de module. En fonction de votre environnement virtuel, les résultats peuvent différer, et vous saurez pourquoi vous avez un Module Not Found.

En python il est possible de construire des fonctions qui acceptent un nombre indéfini de paramètres, aussi bien en positionnel qu’en nommé.

*args

def mafonction(*args):
   for a in args:
        print(a)

mafonction(1)
# 1
mafonction(1,2,3)
# 1
# 2
# 3

le *args est interprété comme un tuple

**kwargs

def mafonction(param,*args,**kwargs):
    for a in kwargs:
        print(a,kwargs[a])

mafonction(nom="Dupont",age=27)
#nom Dupont
#age 27

Notez qu’il n’est pas nécessaire de les appeler *args et **kwargs, on peut utiliser d’autres noms.

On peut mixer ces deux types de paramètre avec des paramètres classiques

def mafonction(param1,*args,**kwargs):
    

Unpack argument list

Cette technique consiste à préfixer le paramètre d’un astérisque, pas lors de la déclaration de la fonction, mais lors de l’appel de la fonction.

def mafonction(a,b,c):
    print(a,b,c)

obj = {"nom":"Dupont","age":27}
mafonction(100,**obj)
# 100,Dupont 27

def mafonction(a,b):
    print(a,b)

l = [1,2]
mafonction(*l)
# 1 2

Pour les listes et tuple on utilisera *args, pour les dictionnaire on utilisera **

mylist = [1,2,3]
>>> foo(*mylist)
x=1
y=2
z=3

>>> mydict = {'x':1,'y':2,'z':3}
>>> foo(**mydict)
x=1
y=2
z=3

>>> mytuple = (1, 2, 3)
>>> foo(*mytuple)
x=1
y=2
z=3

Extended iterable unpacking

Une façon de faire de l’unpacking puissante

first, *rest = [1,2,3,4]
first,*l,last = [1,2,3,4]

Enfin un esyntaxe propre à Python 3 :

def mafonction(arg1,arg2,*,kwarg1,kwarg2):
    pass

La syntaxe ci-dessus impose que les deux premiers paramètres soient positionnel, et les paramètre après l’astérisque soient nommés.

https://stackoverflow.com/questions/36901/what-does-double-star-asterisk-and-star-asterisk-do-for-parameters

Le problème de conversion d’une chaine en nombre entier

Lorsqu’on a une chaine de caractères qu’on cherche à convertir en nombre, il faut se poser la question de si c’est faisable.

Imaginons qu’on ait une variable à tester dont le type est un string :

ns = "125"
n = int(ns)

Mais si on a une chaine de caractère qui ne contient pas purement des chiffres (voire une chaine vide):

nm1 = "12.3"
nm2 = "z123"
nm3 = ""

Tenter de convertir ces chaines en entier déclenchera une erreur de type ValueError.

Tester si une chaine est un nombre entier avec isdigit()

En Python tout est objet, un nombre entier est un objet, un booléen est un objet, un float est un objet,(vous pouvez le voir en utilisant la notation pointée). Ces objets ont des méthodes (c’est le nom en OOP pour une fonction). Et dans le cas des chaines de caractères, uen de ces méthode est isdigit().

n = "123"
print(n.isdigit())  # True 
n = ""
print(n.isdigit())   # False
#on peut encore écrire
print("123".isdigit())  #True

Ainsi avant de convertir en entier, testez la chaine avec isdigit() avant d’utiliser int()

if("123".isdigit()):
    n = int("123")

Installez au préalable Mysql, le plus rapide (avec zéro configuration ) étant d’installer la solution de développement PHP Laragon si vous êtes sous windows.

Ensuite il faudra redéfinir le mot de passe root, allez dans Laragon click droit sur le bouton Database > Mysql > Change root password.

Connexion à Mysql en Python

from mysql.connector import MySQLConnection, Error

def connect():
    """ Connect to MySQL database """
    conn = None
    try:
        conn = mysql.connector.connect(host='localhost',
                                       database='boutique',
                                       user='root',
                                       password='root')
        if conn.is_connected():
            print('Connected to MySQL database')

    except Error as e:
        print(e)

    finally:
        if conn is not None and conn.is_connected():
            conn.close()

if __name__ == '__main__':
    connect()

Exécuter une requête SQL en Python

from mysql.connector import MySQLConnection, Error

def query_with_fetchone():
    try:

        conn = MySQLConnection(host='localhost',
                                         database='boutique',
                                         user='root',
                                         password='root')
        cursor = conn.cursor()
        cursor.execute("SELECT * FROM staffs")

        row = cursor.fetchone()

        while row is not None:
            print(row)
            row = cursor.fetchone()

    except Error as e:
        print(e)

    finally:
        cursor.close()
        conn.close()


query_with_fetchone()

Sqlite est une base de donnée un peu spéciale, puisque la base tient dans un fichier binaire, avec extension .db, c’est donc quelque chose de très simple, et Sqlite est destiné à être utilisé sur des systèmes embarqués.

Donc pas besoin d’installer un programme, c’est la librairie Python qui va s’ocuper de cela. De plus c’est dans la librairie standard, ce qui veut dire que l’on n’ pas besoin de faire un pip install.

La librairie Python sqlite3

Il suffit tout simplement d’importer la librairie sqlite3, de créer une connexion pour créer le fichier binaire de la base de données

import sqlite3
from sqlite3 import Error


def create_connection(db_file):
    """ crée une connexion SQLite si lea DB n'existe pas elle sera créée"""
    conn = None
    try:
        conn = sqlite3.connect(db_file)
        print(sqlite3.version)
    except Error as e:
        print(e)
    finally:
        if conn:
            conn.close()


if __name__ == '__main__':
    create_connection(r"C:\db\pythonsqlite.db")

Sivous exécutez pour la première fois ce script, le fichier pythonslqite.db sera créé, par contre il vous faudra avoir le répertoire déjà créé, sinon vous aurez une erreur. Vous pouvez aussi créer une base de données avec DB Browser, un browser de base sqlite.

Requêter dans Sqlite en Python

Voici la recette pour faire une requête SQL en Python dans Sqlite. On acréé la base de données test.db, et il y a une table items. Vous pouvez importer dans DBBrowser le fichier contenant les données ci-dessous ou exécuter le SQL suivant :

BEGIN TRANSACTION;
CREATE TABLE IF NOT EXISTS "items" (
	"id"	INTEGER,
	"nom"	TEXT,
	"prix"	INTEGER
);
INSERT INTO "items" VALUES (1,'Pomme',5);
INSERT INTO "items" VALUES (1,'Poire',3);
INSERT INTO "items" VALUES (1,'raisin',13);
COMMIT;

import sqlite3
from sqlite3 import Error

def create_connection(db_file):
    conn = None
    try:
        conn = sqlite3.connect(db_file)
    except Error as e:
        print(e)

    return conn

def select_items(conn):
    """
    Query all rows in the tasks table
    :param conn: the Connection object
    :return:
    """
    cur = conn.cursor()
    cur.execute("SELECT * FROM items")

    rows = cur.fetchall()

    for row in rows:
        print(row)

db_file = "c:\\Users\\admin\\Documents\\test.db"
conn = create_connection(db_file)
select_items(conn)