ValueError: Unable to parse string – Python Pandas error

En général vous obtenez cette erreur « ValueError: Unable to parse string » lorsque vous cherchez à convertir en numérique avec la fonction

pd.to_numeric(s)

Introduction – ValueError: Unable to parse string

L’erreur est en général du à la présence de valeur nulle NaN dans le dataset.

Plutôt que d’être en erreur, nous pouvons forcer pandas à considérer NaN comme une valeur numérique manquante / incorrecte.

Nous pouvons contraindre les valeurs invalides à NaN comme suit :

pd.to_numeric(s, errors='coerce')

Obtenir la version installée de pandas

Aussi vous pouvez consulter sur ce site : https://pandas.pydata.org/pandas-docs/stable/getting_started/install.html

Vous pouvez vérifier facilement la version installée sur votre machine en exécutant le code python suivant :

import pandas as pd 
print(pd.__version__)

Vous obtenez par exemple :

ValueError: Unable to parse string
pandas csv - Comment charger/sauvegarder avec pandas en Python ?
Vérifier la version de pandas installée

http://128mots.com/index.php/category/python/

pandas csv – Comment charger/sauvegarder avec pandas en Python ?

Python est un langage adapté pour l’analyse de donnée, le package Pandas est central dans la gestion et l’analyse de donnée ainsi que leur importation. Dans cet article voyons comment charger un fichier de donnée csv excel par exemple avec pandas.

Introduction

La librairie pandas est caractérisée par l’objet DataFrame qui permet de manipuler des données facilement et efficacement.

Pour installer pandas si ce n’est pas encore le cas sur votre poste :

pip install pandas

Aussi vous pouvez consulter sur ce site : https://pandas.pydata.org/pandas-docs/stable/getting_started/install.html

Vous pouvez vérifier facilement la version installée sur votre machine en exécutant le code python suivant :

import pandas as pd 
print(pd.__version__)

Vous obtenez par exemple :

pandas csv - Comment charger/sauvegarder avec pandas en Python ?
Vérifier la version de pandas installée

Charger un fichier csv dans un dataframe pandas :

Pour charger un fichier csv avec python c’est assez simple : vous utilisez la fonction read_csv avec une url ou un fichier en local.

blockdata = pd.read_csv('./blockdata.txt',index_col=0, parse_dates=True)

Voici quelques paramètres utiles :

ParamètreUtilisation
seppermet de préciser un séparateur différent du séparateur par défaut ‘,’
index_colPermet de préciser la colonne à utiliser comme index
use_colsPermet de préciser les colonnes à utiliser

Sauvegarder/Enregistrer un dataframe pandas dans un fichier csv :

Exemple de sauvegarde :

blockdata.to_csv('outblock4.csv')

http://128mots.com/index.php/category/python/

Implémentation Python de l’algorithme de Bellman-Ford

Introduction – algorithme de Bellman-Ford python

Cet article fait suite à d’autres article sur l’implémentation python d’algorithme : l’article suivant sur l’algorithme de Dijkstra : http://128mots.com/index.php/2021/03/01/implementation-python-de-lalgorithme-de-floyd-warshall/

def bellmanFord(graph, sommetDepart):
    distances = {} 
    predecesseurs = {}
    for sommet in graph:
        distances[sommet] = np.inf
        predecesseurs[sommet] = None
    distances[sommetDepart] = 0
    

    for i in range(len(graph)-1):
        for j in graph:
            for k in graph[j]: 
                if distances[k] > distances[j] + graph[j][k]:
                    distances[k]  = distances[j] + graph[j][k]
                    predecesseurs[k] = j
    for i in graph:
        for j in graph[i]:
            assert distances[j] <= distances[i] + graph[i][j]

    return distances, predecesseurs

#Liste d'ajacence du graphe
graph = {'A':{'B':15,'C':4},'B':{'E':5},'C':{'E':11,'D':2},'D':{'E':3},'E':{}}
distances, predecesseurs = bellmanFord(graph,'A')
print("Plus courte distance pour chaque sommet de départ :")
for v in distances: print(str(v) + '-' + str(distances[v]))

L’algorithme pour miner le bitcoin en Python

Cet article décrit une implémentation en python du minage du bitcoin qui s’appuie sur un algorithme basé sur un double hash SHA-256.

bitcoin python algorithme miner minage

Introduction – Principe de l’agorithme de minage du bitcoin

Les mineurs du réseau bitcoin doivent rechercher le nonce qui est un un nombre de 32 bits. Le mineur va tester successivement plusieurs NONCE (1,2,3 ….10^32-1), pour chacun des nonce il crée l’entête suivante et le hasher 2 fois avec une fonction de hachage SHA-256 bits.

FieldDescriptionSize
versionVersion 4
Hash du bloc précédent256-bit hash du block précédent32
Merkle rootIl s’agit d’un hash sur les données du bloc. Il est fournit au mineur et il contient un résumé des transactions qui sont contenues dans le bloc. 32
timeUn timestamp numérique qui représente le nombre de seconde depuis 1970-01-01T00:00 UTC4
bitsLa cible actuelle (Current target) en format compacté4
nonce32-bit number (starts at 0)4

Une fois le hash obtenu le mineur doit ensuite vérifier que le hash obtenu est inférieur au facteur de difficulté cible du bloc. Si le hash obtenu est supérieur alors le nonce n’est pas le bon il faut en tester un autre.

Exemple sur le bloc 671712

Si vous utilisez un explotateur de blochain bitoin (par exemple blocstream info), si on prends par exemple le bloc 671712 :

https://blockstream.info/block/000000000000000000062a949bc297739a12e639ba9e2107638b469afe11d0f8?expand

bitcoin python algorithme miner minage

Dans ce cas voici un algorithme en python qui permet de miner ce bloc :

Dans cette simulation j’affiche le header et le hash calculé ainsi que le hash rate.

Le nonce a trouver pour le bloc 671712 était 4107802144

Soit en hexa : 0xf4d81620

Cette algorithme démarre avec un nonce = 4107802144 – 400 nous allons faire comme si on était à très proche de trouver le bloc (il manque 400 double hash à effectuer pour trouver le bloc) :

import hashlib
from hashlib import sha256
import time
import struct
import binascii
import datetime
from binascii import unhexlify, hexlify
from dateutil import parser
from datetime import datetime
from datetime import timedelta 

nontrouve = True
dtprec = datetime.now()
inonc = 4107802134 - 400 #Starting 400 before the good nonce
resultat = []

while(nontrouve):
    inonc +=1
    if(inonc%50==0):
        print(str(round(timedelta(seconds=1)/(datetime.now() - dtprec))) + ' H/s')
    dtprec = datetime.now()
    header_hex = (binascii.hexlify(struct.Struct('<L').pack(int('0x2fffe000',16))).decode()  + 
     binascii.hexlify(binascii.unhexlify('000000000000000000078908d256fa7a9f97b2e1ea532fb1ce45ee4bf050d221')[::-1]).decode()+
     binascii.hexlify(binascii.unhexlify('c504fc3a406f11c7c5b598da7f50916f4e298041e6f9b91535a80db113af109a')[::-1]).decode() +
     binascii.hexlify(struct.Struct('<L').pack(int(hex(int(parser.parse('2021-02-22 15:14:22 GMT +1').timestamp())-3600),16))).decode() +
     binascii.hexlify(struct.Struct('<L').pack(int("0x170cf4e3",16))).decode() + 
     binascii.hexlify(struct.Struct('<L').pack(int(hex(inonc),16))).decode()) 
    header_bin = unhexlify(header_hex)
    dt1 = datetime.now().strftime("%H:%M:%S.%f")
    hash = hashlib.sha256(hashlib.sha256(header_bin).digest()).digest()
    hexlify(hash).decode("utf-8")
    hexlify(hash[::-1]).decode("utf-8")
    hash=hexlify(hash[::-1]).decode("utf-8") 
    resultat.append([round(int(hash,16)/10**65)])
    
    MAX_TARGET = int("00000000FFFF0000000000000000000000000000000000000000000000000000", 16)           
    Difficulty = 21724134900047.27                     
    target = int(MAX_TARGET / Difficulty)
    target32 = '{:0>64x}'.format(target)    
    if(int(hash,16) < int(target32,16)):
        print('###########BLOC MINED###################')
        print('HEADER=' + header_hex)
        print('HASH=' + hash)
        print('NONCE=' + str(inonc))
        print('NONCE (hex)=' + hex(inonc))
        print('###########BLOC MINED###################')
        break

La sortie est la suivante :

1149 H/s
4405 H/s
4115 H/s
1534 H/s
3831 H/s
2392 H/s
4386 H/s
3165 H/s
###########BLOC MINED###################
HEADER=00e0ff2f21d250f04bee45ceb12f53eae1b2979f7afa56d20889070000000000000000009a10af13b10da83515b9f9e64180294e6f91507fda98b5c5c7116f403afc04c53ebc3360e3f40c172016d8f4
HASH=000000000000000000062a949bc297739a12e639ba9e2107638b469afe11d0f8
NONCE=4107802144
NONCE (hex)=0xf4d81620
###########BLOC MINED###################

Lien externe – minage de bitcoin en python

https://en.bitcoin.it/wiki/Block_hashing_algorithm

Lien interne

http://128mots.com/index.php/2020/03/30/construire-une-application-decentralisee-full-stack-pas-a-pas-ethereum-blockchain-dapp-en-plus-de-128-mots-partie-1/

Installer kubernetes mac os x – Tutorial kubernetes débutant

Kubernetes mac os x, voici des explications pour installer facilement kubernetes sur son mac.

Kubernetes, ou k8s, est une plate-forme open source, lancée par Google, qui a commencé comme un simple outil d’orchestration de conteneurs mais est devenue une plate-forme native pour le cloud.

Installer kubernetes mac os x

Introduction – installer kubernetes mac

Sur mac os x une des méthodes les plus rapide pour installer Kubernetes est d’utiliser HoweBrew (voir le lien : Homebrew). Homebrew est un système de gestion de progiciels gratuit et open source qui simplifie l’installation de logiciels sur le système d’exploitation mac OS x Apple.

J’ai démarrer une console et executé la commande :

brew install kubectl

Vous devriez obtenir une sortie du type :

==> Pouring kubernetes-cli-1.20.2.catalina.bottle.tar.gz
==> Caveats
zsh completions have been installed to:
  /usr/local/share/zsh/site-functions
==> Summary
🍺  /usr/local/Cellar/kubernetes-cli/1.20.2: 246 files, 46.1MB

A la fin de l’installation vous pouvez vérifier que kubernetees est bien installer :

kubectl version --client
kubectl version --client
Client Version: version.Info{Major:"1", Minor:"20", GitVersion:"v1.20.2", GitCommit:"faecb196815e248d3ecfb03c680a4507229c2a56", GitTreeState:"clean", BuildDate:"2021-01-14T05:14:17Z", GoVersion:"go1.15.6", Compiler:"gc", Platform:"darwin/amd64"}

Vous pouvez également installer autocomplétion de shell : kubectl fournit un support d’auto-complétion pour Bash et Zsh :

brew install bash-completion@2

Ensuite :

export BASH_COMPLETION_COMPAT_DIR="/usr/local/etc/bash_completion.d"
[[ -r "/usr/local/etc/profile.d/bash_completion.sh" ]] && . "/usr/local/etc/profile.d/bash_completion.sh"

Activation de l’autocomplétion :

Lancez les commandes suivantes :

echo 'source <(kubectl completion bash)' >>~/.bashrc
kubectl completion bash >/usr/local/etc/bash_completion.d/kubectl
echo 'alias k=kubectl' >>~/.bashrc
echo 'complete -F __start_kubectl k' >>~/.bashrc

Installer Minikube :

minikube est un Kubernetes local qui vise à faciliter l’apprentissage et le développement pour Kubernetes.

J’ai lancé les commandes :

brew install minikube

Liens externes :

https://minikube.sigs.k8s.io/docs/start/

https://kubernetes.io/fr/docs/tasks/tools/install-kubectl/

Liens internes installer kubernetes mac :

http://128mots.com/index.php/2021/01/28/qiskit-textbook-qiskit-tutorial-algorithme-quantique-programmation/

http://128mots.com/index.php/category/python/

Ordinateur quantique prix – Combien coûte un ordinateur quantique ?

Le prix d’un ordinateur quantique évolue entre 10 millions de dollars $ et 25 millions de dollars $. Voici quelques repère pour comprendre le prix d’un ordinateur quantique. L’article vous permettra de comprendre comment la course au quantique s’articule entre les différentes technologies et acteurs.

Ordinateur quantique prix. Combien coûte un ordinateur quantique.

Introduction

Récemment Google a annoncé que sa puce Sycamore était la première à démontrer la «suprématie quantique» (article ici). Cela consiste à prouver que la résolution d’un problème à l’aide d’un algorithme quantique est plus efficace qu’à l’aide d’un algorithme classique. Aussi IBM construit actuellement un ordinateur quantique de 1 121 qubits, Condor (lien). Aussi il sera stocké à l’intérieur d’un « réfrigérateur » à dilution (voir ici). Et le but est de créer un ordinateur quantique et de le rendre disponible en ligne d’ici 2023.

Pour expliquer le prix d’un ordinateur quantique il faut dans un premier temps situer les différents acteurs de cette course au quantique et situer les dates importantes.

Les acteurs et l’écosystème de l’informatique quantique

PRINCIPAUX Acteurs dans le Hardware (CONSTRUCTEURS d’ordinateur quantique ET DE CIRCUITS) :

prix ordinateur quantique

IBM : IBM construit un ordinateur quantique avec 1121 qubits d’ici 2023. Vous pouvez déjà programmer sur des systèmes Quantiques IBM via le cloud IBM sur des simulateurs ou des ordinateurs quantique réel via IBM Quantum Experience (voir mon article sur la programmation quantique avec IBM qiskit)

GOOGLE : Sycamore est un processeur quantique de 53 qubits créé par Google (en savoir plus)

INTEL : Intel crée un processeur « Tangle Lake ». Comme ses concurrents IBM, Google, Rigetti, IMEC et BBN Technologies Intel se base sur une architecture de qubits supraconducteurs.

ALICE AND BOB : développe une solution qui permet de résoudre le problème des erreurs quantiques.

prix ordinateur quantique

D-WAVE : La société D-WAVE crée et commercialise des ordinateurs quantiques.

IONQ : crée un ordinateur quantique à ions piégés.

RIGETTI : Rigetti crée un ordinateur full-stack pour l’informatique hybride classique et quantique.

BRANE CELL

PSIQuantum : L’objectif de PsiQuantum est de construire le premier ordinateur quantique à usage général utile au monde avec au moins 1 millions de Qubits. La société travaille par exemple sur des qubits photoniques.

TURING :XGR-1 est une mémoire quantique révolutionnaire de la première génération de Turing.

QILIMANJARO :Enfin, Qilimanjaro se concentre sur des architectures de qubit de haute qualité de recuit quantique cohérent.

PRINCIPAUX Acteurs dans le SOFTWARE (KIT DE développement, Logiciels, Solutions cryptographiques)

IBM Qiskit :IBM Qiskit permet aux développeurs de créer des algorithmes quantiques à l’aide d’une interface en Python.

MICROSOFT : Q# est un langage de microsoft de programmation qui permet la programmation quantique.

1QBIT : 1QUBIT est une société de service en informatique quantique.

QCWARE : Egalement QCWARE une entreprises qui se concentre sur la création d’algorithmes quantiques.

QUSOFT QuSoft est le centre de recherche néerlandais sur les logiciels quantiques. Sa mission est de développer de nouveaux protocoles, algorithmes et applications pouvant être exécutés sur des prototypes de petite et moyenne taille d’un ordinateur quantique.

STRANGE WORKS : Commercialise des logiciels d’informatique quantiques.

Ordinateur quantique prix – Indication du prix d’un ordinateur quantique

Le prix d’un ordinateur quantique D-WAVE 200Q est par exemple d’environ 15 millions de dollars (15 m$). De plus, cette même entreprise commercialisait un ordinateur quantique 1000Q quelques années auparavant. Et en 2011, D-Wave lance son premier modèle d’ordinateur quantique qui sera disponible dans le commerce. Aussi il coûte 10 millions de dollars. Cela donne une bonne estimation de combien coûte un ordinateur quantique.

BCEWithLogitsLoss Pytorch – Python Class

BCEWithLogitsLoss voici quelques explications complémentaire sur l’utilisation de Binary Cross-Entropy Loss avec Pytorch en python.

On m’a demandé récemment comment trouver le code de Binary Cross-Entropy Loss(https://discuss.pytorch.org/t/implementation-of-binary-cross-entropy/98715/2) pour une fonction appelée dans PYTORCH avec la fonction handle_torch_function.

C’est une combinaison de BCELOSS + une couche Sigmoid. C’est plus stable numériquement que l’utilisation d’un Sigmoid suivie d’un BCELoss comme, ici on tire parti de l’astuce log-sum-exp pour la stabilité numérique voir: https://en.wikipedia.org/wiki/LogSumExp

Bcewithlogitsloss : quelques explications

  1. Le code de la classe se trouve dans https://github.com/pytorch/pytorch/blob/master/torch/nn/modules/loss.py
   def forward(self, input: Tensor, target: Tensor) -> Tensor:
        return F.binary_cross_entropy_with_logits(input, target,
                                                  self.weight,
                                                  pos_weight=self.pos_weight,
                                                  reduction=self.reduction)
BCEWithLogitLoss PYTORCH

Le F oject est importé de functionnal.py ici : https://github.com/pytorch/pytorch/blob/master/torch/nn/functional.py

Vous trouverez la fonction appelée

def binary_cross_entropy_with_logits(input, target, weight=None, size_average=None,
                                     reduce=None, reduction='mean', pos_weight=None):

Il appelle le handle_torch_function dans https://github.com/pytorch/pytorch/blob/master/torch/overrides.py
On trouve une entrée de la fonction binary_cross_entropy_with_logits dans le dictionnaire ret qui contiennent toutes les fonctions qui peuvent être overridé dans pytorch. Il s’agit de l’implémentation Python de torch_function plus d’informations dans https://github.com/pytorch/pytorch/issues/24015

Ensuite, le code appelé est dans le C++
Filehttps://github.com/pytorch/pytorch/blob/master/aten/src/ATen/native/Loss.cpp

Tensor binary_cross_entropy_with_logits(const Tensor& input, const Tensor& target, const Tensor& weight, const Tensor& pos_weight, int64_t 
...
BCEWithLogitLoss PYTORCH

LIENS DE RESSOURCES :

https://pytorch.org/

Liens internes

http://128mots.com/index.php/category/graphes/

http://128mots.com/index.php/category/python/

Apprendre le COBOL – Tutorial pour apprendre COBOL

Apprendre COBOL est un ensemble de connaissances très intéressants. COBOL (COmmon Business Oriented Language) est un langage orienté métier il est très adapté pour le traitement de données avec des hautes performances et précisions, il est proposé par IBM.

Introduction – Apprendre le COBOL

Vous pouvez être sur que tous les achats ou retraits que vous faites avec votre carte bancaire démarre un programme en COBOL. Chaque jours COBOL traite des millions de transactions. De mon point de vue apprendre COBOL est un ensemble de connaissances très intéressants.

J’ai travaillé plus de 10 ans avec ce langage et je partage ici quelques notes qui vous permettrons sans doute de vous faire la main avec.

Le mainframe se modernise avec la possibilité de programmer avec les derniers outils tels que l’éditeur de code libre VsCode etson extension Zowe ainsi que Z Open editor, de s’exécuter dans le cloud dans des environnement tels que Open Shift et d’intégrer les principes devops avec des outils tels que Github, jenkins, Wazi.

Syntaxe COBOL

La syntaxe de COBOL est assez simple et se rapproche du langage naturel en anglais.

Le code est standardisé selon des colonnes qui permettent de décrire 5 zones clés.

Séquence Area : specifie un numéro de sequence de la ligne de code parfois, parfois à blanc

Indicator Area : peut contenir un indicateur par exemple * pour indiquer que la ligne est un commentaire, D pour indiquer que la ligne s’exécute uniquement en debugging mode.

A AREA : Contient les divisions, sections, paragraphes et Levée

B AREA : Sentences et statements du programme cobol for exemple COMPUTE quelques chose…

Identification Area: espace à ignorer et laisser à blanc.

Il y a egalement des mots réservés en COBOL vous trouverez sur le lien la liste des mots réservés en COBOL. https://www.ibm.com/support/knowledgecenter/SSZJPZ_9.1.0/com.ibm.swg.im.iis.ds.mfjob.dev.doc/topics/r_dmnjbref_COBOL_Reserved_Words.html

DIVISIONS :

Le code est structuré par des divisions qui contiennent des Sections composées de Paragraphe eux même constitués par des Sentences et Statements.

Exemple de sentences :

ADD 45 TO PRICE.

A noter que le point corresponds à un terminateur implicite de portée.

Il y a 4 Divisions dans un programmes en COBOL :

– DATA DIVISION : permets de mettre en place la gestion des donnee qui vont être traitees par le programme.

– IDENTIFICATION DIVISION : Nom programme et du du programmeur, date du programme, but du programme.

– ENVIRONEMENT DIVISION : Type d’ordinateur utilise et mapping entre les fichiers utilisé dans le programmes et les dataset sur le système (lien entre le programme et le système)

– PROCEDURE DIVISION : C’est ici qu’est contenu le code métier composé des différents paragraphes à exécuter.

Les variables en Cobol :

Comme dans les autres langages des lettres permettent de représenter des valeurs stockées en mémoire.

Le nom d’une variable est de maximum 30 caractères.

Une clause Picture permet de fixer le type de la variable.

PIC 9 : Numérique la longueur est entre parenthèse.

PIC 9(5) : variable numérique de 5 digits la longueur maximale pour un numérique est 18.

PIC A pour un caractère

PIC X(11) : un alphanumérique avec une longueur maximum de 255

Il est possible d’avoir des types édité au moyen de symboles :

PIC 9(6)V99 pour un numerique de 6 digits et 2 décimales séparés par virgule.

PIC $9,999V99 pour représenter un montant

A noter que COBOL mets à dispositions des literaux constant tels que ZEROES, SPACE, SPACES, LOW-VALUE …

Plus d’information sur ce lien :

https://www.ibm.com/support/knowledgecenter/SS6SG3_4.2.0/com.ibm.entcobol.doc_4.2/PGandLR/ref/rllancon.htm

Si vous débutez sur IBM COBOL et que vous souhaitez faire un apprentissage sérieux et pas trop cher, je vous conseille absolument de lire ce livre :

Ce livre couvre beaucoup de sujet concernant le langage machine, IBM Cobol training, Open Cobol IDE, DB2 pour devenir un véritable Cobol programmers.

Voir aussi mes articles :

Liens internes Apprendre le COBOL

http://128mots.com/index.php/category/python/

Problème du sac à dos – Algorithme en Python (knapsack problem)

Le problème du sac à dos en algorithmique (et son implémentation python) est intéressant et fait parti du programme de Sciences numériques et informatique de première.

Ce problème illustre les algorithmes gloutons qui énumèrent toutes les possibilités de résolution d’un problème pour trouver la meilleure solution.

Le problème du sac à dos algorithme python est un problème d’optimisation, c’est à dire une fonction que l’on doit maximiser ou minimiser et des contraintes qu’il faut satisfaire.

Le problème du sac à dos – algorithme Python

Pour un sac à dos de capacité maximale de P et N articles chacun avec son propre poids et une valeur définie, jetez les articles à l’intérieur du sac à dos de telle sorte que le contenu final ait la valeur maximale.

Le problème du sac à dos - algorithme Python

Exemple d’énoncé :

  • Capacité maximum du sac à dos : 11 unités
  • Nombre d’objet : 5
  • Valeurs des objets : {10,50,20,30,60}
  • Poids des objets : {1,5,3,2,4}

Quelles est la valeur maximum qu’il est possible de mettre dans le sac à dos en considérant la contrainte de capacité maximum du sac qui est de 11 ?

Algorithme glouton python

Une solution efficace consiste à utiliser un algorithme glouton. L’idée est de calculer le rapport valeur / poids pour chaque objet et de trier l’objet sur la base de ce rapport calculé .

On prends l’objet avec le ratio le plus élevé et on ajoute jusqu’à ce qu’on ne puisse plus en ajouter.

En version fractionnaire il est possible d’ajouter des fractions d’article au sac à dos.

Implémentation du problème du sac à dos Python – version non fractionnaire

Voici une implémentation du problème du sac à dos python en version non fractionnaire, c’est à dire qu’on ne peut pas ajouter de fraction d’un objet dans le sac. Seul des objets entiers peuvent être ajoutés.

class ObjetSac: 
    def __init__(self, poids, valeur, indice): 
        self.indice = indice         
        self.poids = poids 
        self.valeur = valeur
        self.rapport = valeur // poids 
  #Fonction pour la comparaison entre deux ObjetSac
  #On compare le rapport calculé pour les trier
    def __lt__(self, other): 
        return self.rapport < other.rapport 
  

def getValeurMax(poids, valeurs, capacite): 
        tableauTrie = [] 
        for i in range(len(poids)): 
            tableauTrie.append(ObjetSac(poids[i], valeurs[i], i)) 
  
        #Trier les éléments du sac par leur rapport
        tableauTrie.sort(reverse = True) 
  
        compteurValeur = 0
        for objet in tableauTrie: 
            poidsCourant = int(objet.poids) 
            valeurCourante = int(objet.valeur) 
            if capacite - poidsCourant >= 0: 
                #on ajoute l'objet dans le sac
                #On soustrait la capacité
                capacite -= poidsCourant 
                compteurValeur += valeurCourante
                #On ajoute la valeur dans le sac 
        return compteurValeur 


poids = [1,5,3,2,4] 
valeurs = [10,50,20,30,60] 
capacite = 11
valeurMax = getValeurMax(poids, valeurs, capacite) 
print("Valeur maxi dans le sac à dos =", valeurMax) 

Le résultat obtenu est le suivant :

py sacados.py 
Valeur maxi dans le sac à dos = 120

Implémentation du problème du sac à dos python – version fractionnaire

En version fractionnaire de l’agorithme du sac à dos python on peut ajouter des fractions d’objet au sac à dos.

class ObjetSac: 
    def __init__(self, poids, valeur, indice): 
        self.indice = indice         
        self.poids = poids 
        self.valeur = valeur
        self.rapport = valeur // poids 
  #Fonction pour la comparaison entre deux ObjetSac
  #On compare le rapport calculé pour les trier
    def __lt__(self, other): 
        return self.rapport < other.rapport 
  

def getValeurMax(poids, valeurs, capacite): 
        tableauTrie = [] 
        for i in range(len(poids)): 
            tableauTrie.append(ObjetSac(poids[i], valeurs[i], i)) 
  
        #Trier les éléments du sac par leur rapport
        tableauTrie.sort(reverse = True) 
  
        compteurValeur = 0
        for objet in tableauTrie: 
            poidsCourant = int(objet.poids) 
            valeurCourante = int(objet.valeur) 
            if capacite - poidsCourant >= 0: 
                #on ajoute l'objet dans le sac
                #On soustrait la capacité
                capacite -= poidsCourant 
                compteurValeur += valeurCourante
                #On ajoute la valeur dans le sac 
            else: 
                fraction = capacite / poidsCourant 
                compteurValeur += valeurCourante * fraction 
                capacite = int(capacite - (poidsCourant * fraction)) 
                break
        return compteurValeur 


poids = [1,5,3,2,4] 
valeurs = [10,50,20,30,60] 
capacite = 11
valeurMax = getValeurMax(poids, valeurs, capacite) 
print("Valeur maxi dans le sac à dos =", valeurMax) 

Le résultat obtenu est le suivant :

py sacados.py 
Valeur maxi dans le sac à dos = 140.0

Liens internes algorithme python :

http://128mots.com/index.php/category/python/

http://128mots.com/index.php/2021/01/21/algorithme-glouton-python/
http://128mots.com/index.php/2021/01/19/levenshtein-python/
http://128mots.com/index.php/2021/01/13/algorithme-tri-quantique/

Liens externes algorithme python :

http://math.univ-lyon1.fr/irem/IMG/pdf/monnaie.pdf

http://www.dil.univ-mrs.fr/~gcolas/algo-licence/slides/gloutons.pdf

Construire une application décentralisée full-stack pas à pas (Ethereum Blockchain Dapp) en plus de 128 mots – Partie 3

Cet article fait suite aux deux premiers articles sur le sujet :

Les 2 premiers articles permettent de mieux comprendre le concept de blockchain et d’application décentralisée.

Création du projet

On crée un répertoire pour le projet d’application de vote sur des chansons.

mkdir vote-chanson-dapp

Pour accélérer le développement on va utiliser une « truffle box » : https://www.trufflesuite.com/boxes

C’est en quelques sorte un modèle, un canevas d’application qui vous permet de vous focaliser sur la Dapp en ayant une structure déjà créée.

Je vais baser mon explication sur la pet-shop box disponible ici : https://www.trufflesuite.com/tutorials/pet-shop. C’est un des premiers tutos de truffle pour créer une Dapp.

Cette truffle box comprend la structure de base du projet ainsi que le code de l’interface utilisateur.

Utilisez la commande truffle unbox :

truffle unbox pet-shop

Pour rappel l’installation de truffle est possible via la commande :

npm install -g truffle

Si vous ouvrez le dossier vote-chason-dapp avec vscode vous obtenez alors l’arborescence suivante :

Arborescence du projet de l’application Dapp exemple (basée sur pet-shop de truffle)
  • contract : stockage du smart contract de l’application
  • migration : Les migrations permettent de transférer les smarts contracts vers la blockchain Ethereum (en local test ou mainnet). Les migrations permettent également de relier des smart contrats avec d’autres smarts contracts et de les initialiser.
  • node_modules : Le dossier node_modules contient les bibliothèques téléchargées depuis npm.
  • src : Répertoire de l’application front-end (client)
  • test : Stockage des tests pour l’application
  • truffle-config.js : fichier Javascript qui peut exécuter tout code nécessaire pour créer votre configuration.

Création du smart contract

Pour rappel nous développons une application qui permet d’élire la chanson préférée des électeurs.

Nous allons créer dans un premier temps la partie qui permet de créer un vote pour la meilleure chanson basée sur 3 chansons éligibles.

Le contrat écrit en solidity est le suivant :

contract TopChanson {
        struct Chanson {
        uint identifiant;
        string titre;
        uint compteur;
    }
    uint public compteurDeChansons;
    mapping(uint => Chanson) public chansons;

    function ajouterChansonElligible (string memory nomChanson) private {
        compteurDeChansons ++;
        chansons[compteurDeChansons] = Chanson(compteurDeChansons, nomChanson, 0);
    }

    function TopChansons() public {
        ajouterChansonElligible("Au clair de la lune");
        ajouterChansonElligible("Maman les p'tits bateaux");
        ajouterChansonElligible("Ah ! Les crocodiles");
    }

}

A noter l’utilisation de « mapping(uint => Chanson) public chansons; »

A lire : https://solidity.readthedocs.io/en/v0.6.6/types.html#mapping-types

Cette structure de donnée va nous permettre de stocker les titres des chansons éligibles à la façon d’une table de hachage. C’est à dire un tableau qui prend pour clé d’accès dans notre cas un uint qui est l’identifiant de la chanson et permet de récupérer la valeur qui est un type Chanson structuré.

Le type Chanson est structuré, voir la documentation solidity : https://solidity.readthedocs.io/en/v0.6.6/types.html#structs

Ici il y a un cas particulier sur la fonction ajouterChansonElligible, elle prends en argument le nom de la chanson qui est une chaine de caractère STRING. Si on ajoute pas le mot clé « memory » on obtient l’erreur suivante:

TypeError: Data location must be « storage » or « memory » for parameter in function, but none was given.

Pour les paramètres de fonction et les variables de retour, l’emplacement des données doit être explicité pour toutes les variables de type (struct, mapping, string).

La migration du contrat s’effectue via la commande :

truffle migrate --reset

On obtient alors :

Compiling your contracts...
===========================
> Compiling ./contracts/Migrations.sol
> Compiling ./contracts/TopChanson.sol

A suivre …