Cet article parlera de codes de programmation de virus simples en Python et de la manière d'utiliser Python pour créer des virus frauduleux. J'espère qu'il vous sera utile. N'oubliez pas de mettre ce site dans vos favoris.
Le programme de simulation de propagation de virus peut également utiliser Python.
Aperçu
La chose est comme ça. @ele Lab, le maître UP de la Station B, a écrit un simple programme de simulation de propagation de l'épidémie pour dire à tout le monde l'importance de rester à la maison. Je crois que tout le monde a regardé la vidéo, et le maître UP a également publié la source. Code python Exemple Basic 100 Cas .
Comme il a été développé en Java, je n’y ai pas prêté beaucoup d’attention au début. Plus tard, j'ai vu quelqu'un analyser le code et j'ai découvert que je pouvais le comprendre, puis j'ai réfléchi à la façon de l'implémenter en Python.
Une brève analyse des programmes de la version Java
Une personne est un point de coordonnées (x, y) et chaque personne a un état.
classe publique La personne étend le point {
état int privé = État.NORMAL ;
}
À chaque cycle d'itération, chaque personne est traversée et chaque personne effectue certaines actions en fonction de son propre statut, notamment :
se déplacer
changement de statut
influencer les autres
Les évolutions spécifiques de ces actions dépendent des différents coefficients définis.
Après une itération, ces points sont imprimés et différents états correspondent à différentes couleurs.
La classe de dessin Java Graphics est utilisée directement dans la partie dessin.
Idées de versions Python
Que devons-nous faire si nous voulons l’implémenter en Python ?
Si la version Java est entièrement copiée, chaque itération doit parcourir tout le monde et calculer la distance par rapport aux autres, ce qui correspond à N^2 calculs. S’il y a 1 000 personnes, il faudra faire un million de cycles. Les performances de ce Python sont définitivement médiocres.
Cependant, Python possède numpy, qui peut fonctionner rapidement sur des tableaux. Combiné avec matplotlib, des graphiques peuvent être dessinés.
importer numpy en tant que np
importer matplotlib.pyplot en tant que plt
Comment simuler une foule
Afin de réduire le nombre de fonctions se transmettant des paramètres et l'utilisation de variables globales, nous définissons également une classe :
classe Personnes (objet):
def __init__(self, count=1000, first_infected_count=3) :
self.count = compte
self.first_infected_count = first_infected_count
auto.init()
Les données de coordonnées de chacun sont un tableau de N lignes et 2 colonnes, accompagnées d'un certain état :
def init(soi) :
self._people = np.random.normal(0, 100, (self.count, 2))
auto.reset()
La valeur d'état et la minuterie sont également des tableaux, et un nombre spécifié de personnes sont sélectionnées au hasard pour être infectées à chaque fois :
def réinitialiser (auto):
soi._round = 0
self._status = np.array([0] * self.count)
self._timer = np.array([0] * self.count)
self.random_people_state(self.first_infected_count, 1)
Le point clé ici est que la taille du tableau auxiliaire est cohérente avec le nombre de personnes, afin qu'une correspondance individuelle puisse être formée.
Les talents dont le statut change enregistrent le temps :
def random_people_state(self, num, state=1) :
"""Sélectionnez au hasard des personnes pour définir leur statut
"""
affirmer self.count > num
# TODO : Dans des cas extrêmes, une boucle infinie peut se produire
n = 0
tandis que n < num :
je = np.random.randint(0, self.count)
si self._status[i] == état :
continuer
autre:
self.set_state(i, état)
n+= 1
def set_state (soi, je, état):
self._status[i] = état
# Enregistrez l'heure à laquelle le statut change
self._timer[i] = self._round
Grâce à la valeur de statut, vous pouvez filtrer les foules, et chaque foule est une vue partielle des personnes. Les fonctions de numpy ici sont assez puissantes et ne peuvent être implémentées qu'avec une syntaxe très concise :
@propriété
définitivement en bonne santé (soi):
retourner self._people[self._status == 0]
@propriété
def infecté (auto):
retourner self._people[self._status == 1]
Selon l’idée établie, on définit d’abord les actions à réaliser à chaque itération :
mise à jour def (auto):
"""Mettre à jour chaque itération"""
self.change_state()
self.affect()
soi.move()
self._round += 1
auto.report()
L'ordre est légèrement différent de celui de l'analyse initiale, mais ce n'est pas très important, vous pouvez également modifier leur ordre.
Comment changer de statut
Cette étape consiste à mettre à jour le tableau d'état self._status et le tableau de minuterie self._timer :
def change_state(soi) :
dt = self._round - self._timer
# L'horloge doit d'abord être mise à jour, puis l'état
d = np.random.randint(3, 5)
self._timer[(self._status == 1) & ((dt == d) | (dt > 14))] = self._round
self._status[(self._status == 1) & ((dt == d) | (dt > 14))] += 1
Filtrez toujours les cibles à modifier via le découpage, puis mettez-les toutes à jour.
L'implémentation spécifique ici est très simple, sans introduire trop de variables :
Le statut des personnes infectées au cours d'une certaine période doit être confirmé. Je suppose simplement ici que la personne confirmée est admise à l’hôpital, donc la possibilité de continuer à infecter d’autres est perdue (voir ci-dessous). Si vous souhaitez compliquer les choses, vous pouvez introduire des états tels que lit d'hôpital, guérison et décès.
comment influencer les autres
Influencer les autres constitue le goulot d’étranglement des performances de l’ensemble du programme, car la distance entre chaque personne doit être calculée.
La simplification continue ici, et seules les personnes infectées sont traitées :
def infect_possible(self, x=0., safe_distance=3.0) :
"""Infecter les personnes en bonne santé à proximité selon la probabilité
La valeur de x fait référence au tableau de probabilité de distribution normale. Lorsque x = 0, la probabilité d'infection est de 50 %.
"""
pour inf dans self.infected :
dm = (self._people - inf) ** 2
d = dm.sum(axe=1) ** 0,5
index_trié = d.argsort()
pour moi dans sorted_index :
si d[i] >= safe_distance :
break # Hors de portée, ne vous inquiétez pas
si self._status[i] > 0 :
continuer
si np.random.normal() > x :
continuer
soi._status[i] = 1
# Enregistrez l'heure à laquelle le statut change
self._timer[i] = self._round
Comme vous pouvez le voir, la distance est toujours calculée via des opérations matricielles numpy. Cependant, chaque personne infectée doit être calculée séparément, donc s'il y a beaucoup de personnes infectées, l'efficacité de traitement de Python est impressionnante.
Comment bouger
_people est une matrice de coordonnées, générez simplement la matrice de distance de déplacement dt puis ajoutez-la. Nous pouvons définir une largeur de plage mobile pour contrôler la distance de déplacement dans une certaine plage.
def move(self, largeur=1, x=.0) :
mouvement = self.random_movement(width=width)
# Limiter la circulation des personnes dans des États spécifiques
switch = self.random_switch(x=x)
mouvement[switch == 0] = 0
self._people = self._people + mouvement
Ici, nous devons également ajouter une option pour contrôler l'intention de mouvement, qui utilise toujours la probabilité de distribution normale. Considérant que ce scénario peut être réutilisé, cette méthode a été spécialement extraite et un tableau contenant uniquement 0 1 a été généré pour faire office de commutateur.
def random_switch(soi, x=0.) :
"""Générer aléatoirement un interrupteur, 0 - off, 1 - on
La plage de valeurs approximatives de x est de -1,99 à 1,99 ;
Correspond à la probabilité de distribution normale. Lorsque la valeur est 0, la probabilité correspondante est de 50 %.
:param x : rapport de commutation de commande
:retour:
"""
normal = np.random.normal(0, 1, self.count)
switch = np.where(normal < x, 1, 0)
interrupteur de retour
Résultats de sortie
Après avoir obtenu toutes les données et modifications, la prochaine chose la plus importante est d’afficher les résultats sous forme graphique. Utilisez simplement le nuage de points de matplotlib directement :
rapport def (auto):
plt.cla()
# plt.grid(Faux)
p1 = plt.scatter(self.healthy[:, 0], self.healthy[:, 1], s=1)
p2 = plt.scatter(self.infected[:, 0], self.infected[:, 1], s=1, c='rose')
p3 = plt.scatter(self.confirmed[:, 0], self.confirmed[:, 1], s=1, c='rouge')
plt.legend([p1, p2, p3], ['sain', 'infecté', 'confirmé'], loc='en haut à droite', scatterpoints=1)
t = "Ronde : %s, Sain : %s, Infecté : %s, Confirmé : %s" % \
(self._round, len(self.healthy), len(self.infected), len(self.confirmed))
plt.text(-200, 400, t, ha='gauche', wrap=True)
effet réel
démarrer.
si __name__ == '__main__' :
np.random.seed(0)
plt.figure(figsize=(16, 16), dpi=100)
plt.ion()
p = Personnes (5 000, 3)
pour moi dans la plage (100):
p.update()
p.report()
plt.pause(.1)
plt.pause(3)
Cette petite démo étant principalement utilisée pour la pratique personnelle, certains paramètres ne sont pas entièrement extraits pour le moment. Si nécessaire, vous ne pouvez modifier que directement le code source.
post-scriptum
À partir des résultats de multiples expériences, des conclusions intuitives peuvent être tirées en ajustant des facteurs tels que la volonté de mobilité du personnel et la distance de mobilité.
C'est la première fois que j'utilise numpy et matplotlib. J'apprends et je vends maintenant. Veuillez me corriger si je les utilise de manière inappropriée. Les paramètres de probabilité n'ont fondamentalement aucune base scientifique et sont uniquement destinés à la référence des passionnés de Python.
En général, il devrait être possible d'utiliser numpy pour simuler une infection virale. Toutefois, les facteurs d’influence doivent encore être soigneusement définis. La performance est également une question à considérer.
Résumer
Ce qui précède est un nouveau programme de simulation de propagation d'une épidémie de coronavirus écrit en Python et présenté par l'éditeur. J'espère qu'il vous sera utile. Merci beaucoup pour votre soutien au site Web Script House !