** Créer et comprendre des arbres de décision à partir de zéro en Python ** 1. Présentation --2 Principes de base du programme Python
Je vais expliquer le programme Python pour créer un arbre de décision.
#commentaire
a = 1 #commentaire
'''Ce qui suit sera un commentaire
b = c
c = d
'''
#Les variables sont typées dynamiquement
# =Attribue (copie) les valeurs de droite à gauche.
i = 1 #Type entier(int)
f = 2.1 #Type à virgule flottante(float)
s = "a" #Type de caractère(string)
b = True #Type booléen(bool)
l = [0,1,2] #Tableau, type de liste
t = (0,1,2) #Type de taple
d = {"a":0, "b":1} #Dictionnaire, type de tableau associatif
print(i,f,s,b,l,t,d)
# 1 2.1 a True [0, 1, 2](0, 1, 2) {'a': 0, 'b': 1}
#Si vous voulez connaître le type, utilisez type.
print(type(i)) #production<class 'int'>
#La variable ne contient pas la valeur réelle, mais stocke la valeur réelle
#Il s'agit d'une variable appelée type de référence qui pointe vers un emplacement.
#Vous pouvez obtenir l'identifiant de la valeur réelle par id.
print(id(l)) # 00000000000000 (Cela dépend de l'exécution)
l2 = l #Par exemple, une copie d'un tableau ne fait référence qu'à deux et le tableau réel n'en est qu'un.
print(id(l2)) # 00000000000000 (Id ci-dessus(l)Sera la même valeur que)
#Puisqu'il n'y a qu'un seul tableau réel, l'ajout d'un élément avec une référence à l2 semblera également avoir été ajouté au tableau l.
l2.append(1)
a = 1 #a contient 1
b = a #b contient également 1
a = 2 #a est écrasé par 2, b reste inchangé
a += 1 #La valeur de a augmente de un(À ce stade, a vaut 3)
a -= 1 #La valeur de a est décrémentée de un(À ce stade, a vaut 2)
a *= 2 #La valeur d'un double(À ce stade, a vaut 4)
a /= 3 #La valeur de a devient un tiers(À ce stade, a vaut 1.3333333333333333)
a = 1+2-3*4/5 #Calculé dans l'ordre de multiplication, division, addition, soustraction, a vaut 0.6
# (Cependant, l'erreur en virgule flottante est en fait 0.6000000000000001)
a = 0
#Spécifiez les conditions d'exécution du groupe de programmes indenté en bas à droite.
#Il y a des conditions, des répétitions, des fonctionnalisations, etc. montrées ci-dessous.
if a == 1:
#La ligne qui est décalée vers la droite par le retrait après si est la ligne qui est décalée vers la droite du même montant sur le côté gauche de la ligne à partir de cette ligne
#Composez un groupe de programmes.
print(1)
print(2)
pass #Indique la fin du groupe jusqu'à présent, explicitement en retrait.
#Les lignes ci-dessus sont un groupe de programmes qui seront exécutés lorsque les conditions if sont remplies.
print(3) #Sortie quelle que soit la valeur de a, non soumise à ce qui précède si
#Sortie 3
#Exécuter ou non, une seule fois si exécuté
si condition:
# program group
#Répéter l'exécution uniquement pour les éléments du tableau.
#Les éléments du tableau sont affectés à la variable v au milieu de la répétition dans l'ordre de face.
pour v dans le tableau:
# program group
#Continuez à exécuter le groupe de programmes tant que les conditions sont remplies
en condition:
# program group
#Décidez quand exécuter plus tard
#(Créez un groupe et donnez-lui un nom pour le moment)
def Nom du groupe de programmes():
# program group
#Le résultat de l'exécution de ce groupe de programmes a été exécuté à l'aide de return.
#Il peut être rendu sur place.
return
#C'est une erreur
#Impression des changements de retrait(2)Devient un autre groupe de programme.
#Mais le groupe de programmes 2 n'a pas d'explication
if a == 1:
#groupe de programmes 1 Le contrôle de ce groupe de programmes est si==1:
print(1)
#groupe de programmes 2 Une erreur se produit car il n'y a pas de partie commande pour ce groupe de programmes.
print(2)
a = 1
b = 2
c = 2
#a et b sont identiques, et a et c sont différents
if a==b and a!=c:
print("Seul c est différent")
#a est supérieur ou égal à b(a et b contiennent le même), Ou a dépasse c(a et c ne contiennent pas les mêmes)
elif a>=b or a>c:
print("a est supérieur ou égal à b ou supérieur à c")
# if,Autres que les conditions elif
else:
print("autre que ça")
#Sortie autre que celle
a = 1
b = 2
#0 est attribué à v si a et b sont identiques, et 1 est attribué dans le cas contraire.
v = 0 if a==b else 1
print(v)
#Sortie 1
for v in [0,1,2,3]: #Tableau[0,1,2,3]Le traitement suivant est répété pour le nombre d'éléments de.
#Traitement, à ce moment, v est mis aux éléments du tableau dans l'ordre de l'avant.
print(v)
pass #Terminez explicitement le retrait ici.
#Sortie 0 1 2 3
#En utilisant enumerate, l'index et la valeur du tableau peuvent être obtenus dans le processus itératif.
for i,v in enumerate([5,3,7,8]):
#i est l'indice et v la valeur de l'élément.
print("(",i,v,")")
#production( 0 5 ) ( 1 3 ) ( 2 7 ) ( 3 8 )
#Avec zip, deux tableaux peuvent être combinés en un seul et itératif.
for v0,v1 in zip([1,2,3,4],[5,6,7,8]):
#v0 contient les éléments du tableau du premier argument de zip, et v1 contient les éléments du deuxième argument.
print("(",v0,v1,")")
#production( 1 5 ) ( 2 6 ) ( 3 7 ) ( 4 8 )
a = 3
#a vaut 0 ou plus
while a>=0:
print(a)
#Diminuer la valeur de a par un
a -= 1
#Sortie 3 2 1 0
#Définition de la fonction Le nom est fonction_name,Les arguments sont param1 et param2, et param2 est l'argument par défaut.
#L'argument utilisé lorsqu'il n'est pas défini lors de l'appel de la fonction est spécifié.
def function_name(param1,param2=1):
print("p1:",param1,"p2",param2)
#Cette fonction appellera param1+Renvoie le résultat de param2.
return param1 + param2
#Appeler une fonction (pour la première fois ici, fonction_Le programme nommé nom s'exécute
#param1 a 5 arguments, param2 n'est pas défini (utilisez les arguments par défaut)
v = function_name(5)
#production(function_Sortie par instruction d'impression dans la fonction de nom) p1: 5 p2 1
print("Valeur de retour",v)
#Valeur de retour de sortie 6
#Nom de la fonction= lambda (argument) : (Valeur de retour)Écrivez la fonction de la manière d'écrire.
f = lambda x: x*x
#Lors de l'appel, c'est la même chose que la définition de la fonction par def
v = f(2)
print(v) #Afficher comme 4
si = "1" #Type de caractère
sf = "2.3" #Type de caractère
i = 4 #Type entier
#Entier ⇒ La conversion de caractères et l'ajout de chaînes de caractères sont des combinaisons de caractères.
print(str(i)+si)
# 41
#Caractère ⇒ Conversion d'entiers, l'addition après la conversion d'entiers est l'addition d'entiers tels quels
print(i+int(si))
# 5
#Caractère ⇒ conversion en virgule flottante, entier+Le résultat du calcul en virgule flottante est automatiquement changé en virgule flottante
print(i+float(sf))
# 6.3
#Génération de séquence
a = [1,1,2,3,2] # a=[[1,1,2,3,2]
b = [n for n in range(8)] # b=[0, 1, 2, 3, 4, 5, 6, 7]
#référence
#La valeur négative est-C'est un index qui compte à partir de l'arrière avec 1 comme dernier élément.
v = a[0] # v=1
v = a[-1] # v=2
#ajouter à
a += [4] # a=[1, 1, 2, 3, 2, 4]
a.append(5) # a=[1, 1, 2, 3, 2, 4, 5]
#sortir(A avant l'exécution=[1, 1, 2, 3, 2, 4, 5])
v = a.pop(0) # v=1, a=[1, 2, 3, 2, 4, 5]
#tranche(A avant l'exécution=[1, 2, 3, 2, 4, 5])
# a[Premier index:Indexer un avant la fin]
# a[:]Si l'index est omis comme dans, le premier est 0 et le dernier est le nombre d'éléments.
c = a[1:3] # c=[2, 3]
#Maximum minimum(A avant l'exécution=[1, 2, 3, 2, 4, 5])
mx,mi = max(a),min(a) # mx=5, mi=1
#moyenne(mean),Médian(median), Le plus fréquent(mode),écart-type(stdev), Distribué(variance)
# (A avant l'exécution=[1, 2, 3, 2, 4, 5])
from statistics import mean,median,mode,stdev,variance
v = mean(a) # v=2.8333333333333335
v = median(a) # v=2.5
v = mode(a) # v=2
v = stdev(a) # v=1.4719601443879744
v = variance(a) #v=2.1666666666666665
#Suppression des doublons(A avant l'exécution=[1, 2, 3, 2, 4, 5])
c = set(a) # c={1, 2, 3, 4, 5}
#Trier (créer un nouveau tableau trié)(A avant l'exécution=[1, 2, 3, 2, 4, 5])
c = sorted(a) # c=[1, 2, 2, 3, 4, 5](a reste inchangé)
#Trier (remplacer le contenu du tableau par celui trié)(A avant l'exécution=[1, 2, 3, 2, 4, 5])
a.sort() # a=[1, 2, 2, 3, 4, 5]
#La génération, la clé est la météo, la température et le tableau est spécifié pour la valeur.
d = {
"langue nationale" : [81, 60, 97, 96],
"Math" : [80, 78, 75, 96],
"Anglais" : [76, 85, 65, 88],
}
print(d)
#production{'langue nationale': [81, 60, 97, 96], 'Math': [80, 78, 75, 96], 'Anglais': [76, 85, 65, 88]}
#Obtenir la valeur en spécifiant la clé
a = d["Math"] # a=[80, 78, 75, 96]
#Définir les valeurs en spécifiant une clé (écraser)
d["Anglais"] = [77, 61, 91, 87] # d["Anglais"]=[77, 61, 91, 87]
#Boucle de données
for k,v in d.items():
print(k,v)
#Langue nationale de sortie[81, 60, 97, 96]Math[80, 78, 75, 96]Anglais[77, 61, 91, 87]
#Maximum, minimum (dans le cas du score de langue nationale)
jmx,jmi = max(d["langue nationale"]),min(d["langue nationale"])
#print(jmx,jmi)
#Acquisition du nom du sujet avec la valeur moyenne la plus élevée
from statistics import mean
#Pour max du tableau de type dictionnaire, vous pouvez spécifier une fonction dans l'argument clé pour savoir quoi utiliser pour trouver le maximum.
#Dans ce cas, l'argument k(Valeur de clé de type de dictionnaire)La formule lambda est utilisée pour trouver la moyenne des valeurs.
kmx = max(d,key=lambda k:mean(d[k])) # kmx="langue nationale"
Recommended Posts