J'écrirai sur les algorithmes et Python. Cette fois, j'écrirai non seulement comment trouver un calcul simple à l'aide d'une fonction, mais aussi comment le trouver lorsque la fonction n'est pas utilisée.
◯ À propos des symboles pour effectuer des calculs.
| opérateur | sens | Exemple | résultat |
|---|---|---|---|
| + | une addition | 3 + 4 | 7 |
| - | soustraction | 10 - 2 | 8 |
| * | Multiplier | 5 * -6 | -30 |
| / | Division des nombres à virgule flottante | 5 / 2 | 2.5 |
| // | Division entière | 5 // 2 | 2 |
| % | Trop de division | 7 % 2 | 1 |
| ** | ~Balade(indice) | 2 ** 4 | 16 |
◯ À propos des symboles de comparaison. Renvoie une valeur booléenne True ou False.
| sens | opérateur |
|---|---|
| égal | == |
| Inégal | != |
| Plus petite | < |
| Moins que | <= |
| Plus grand | > |
| Inégal | >= |
| Est un élément | in ~ |
◯ La notation d'inclusion de liste est utilisée pour créer efficacement divers types de listes. J'aimerais également utiliser diverses listes dans cet article, je vais donc l'écrire à l'avance.
C'est une façon de faire une liste. Il est défini sous la forme de ** [élément pour élément à stocker dans la liste] **. Le ** élément ** stocké dans la liste est une ** expression ** qui utilise l'élément. ** Les objets itérables ** sont des objets qui peuvent être récupérés un par un.
◯ La fonction range () renvoie un objet itérable.
ex0.py
#Extrayez les entiers de 1 à moins de 10 un par un et stockez leurs valeurs dans la liste des nombres.
numbers = [number for number in range(1,10)]
print(numbers)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
ex1.py
#Prend les entiers de 1 à moins de 10 un par un et stocke la valeur multipliée par 2 dans la liste des nombres.
numbers = [number * 2 for number in range(1,10)]
print(numbers)
[2, 4, 6, 8, 10, 12, 14, 16, 18]
ex2.py
#Extrayez les entiers de 1 à moins de 10 un par un et stockez uniquement les valeurs paires dans la liste des nombres.
numbers = [number for number in range(1,10) if number % 2 == 0]
print(numbers)
[2, 4, 6, 8]
ex3.py
#Liste des chaînes
list_1 = ['1','2','3']
#Liste de la liste des chaînes_Extraire les éléments de 1 un par un, les convertir en entiers et les stocker dans les numéros de liste
numbers = [int(i) for i in list_1]
print(numbers)
[1, 2, 3]
ex4.py
#Si l'élément extrait est impair, stockez-le tel quel, et s'il est pair, stockez-le après le carré.
numbers = [i if i % 2 == 1 else i**2 for i in range(10)]
print(numbers)
[0, 1, 4, 3, 16, 5, 36, 7, 64, 9]
◯ C'est une valeur moyenne généralement connue. Il peut être calculé par la valeur totale des éléments / le nombre d'éléments.
◯ Importez la bibliothèque standard `` statistiques '' pour pouvoir utiliser la fonction mean ().
#Module d'importation
import statistics
numbers = [1,2,3,4,5,6]
#moyenne dans le module statistiques()Une fonction
mean_of_numbers = statistics.mean(numbers)
print('mean =',mean_of_numbers)
mean = 3.5
◯ ** Point **: Module Un fichier qui résume le code Python associé. Il est utilisé sous la forme de «module d'importation».
◯ ** Point **: Point (.)
Le point signifie ** aller à l'intérieur **.
Pour utiliser les fonctions et les variables à l'intérieur d'un module, utilisez module.function '' ou module.variable '', comme statistics.mean ().
◯Point: Documentation officielle: statistiques
◯ ** Calculer par la valeur totale des éléments / nombre d'éléments **.
#Essayez de définir les éléments de la liste dans la notation d'inclusion de liste
#La liste à définir est[1,2,3,4,5,6]
numbers = [number for number in range(1,7)]
#Moyenne = valeur totale/Nombre d'éléments
average = sum(numbers)/len(numbers)
print('numbers = ',numbers)
print('average of numbers = ', average)
numbers = [1, 2, 3, 4, 5, 6]
average of numbers = 3.5
◯ La moyenne géométrique est utilisée lorsqu'il s'agit de ** données représentées par le taux de changement **. (Exemple) Si votre épargne augmente à un taux annuel de 5%, elle sera multipliée par 1,05. Si la valeur augmente à un taux annuel de 7% l'année suivante, ce sera le montant obtenu en multipliant le montant de l'épargne initiale par 1,05 puis en le multipliant par 1,07. La moyenne géométrique est utilisée pour ** obtenir la moyenne annuelle du taux de changement ** à ce moment.
◯ La formule de calcul de la moyenne géométrique (géométrie_moyenne) est ** xG = n√ x1 * x2 * x3 *… * xn **. En d'autres termes, il peut être obtenu en multipliant toutes les données (taux de changement) et en prenant la racine du nombre de données.
◯ [Signification et méthode de calcul de la moyenne géométrique (moyenne synergique) -Calcul du taux de croissance moyen-](https://toukeigaku-jouhou.info/2015/08/23/geometric-mean/#:~:text=% E5% B9% BE% E4% BD% 95% E5% B9% B3% E5% 9D% 87% EF% BC% 88geometric% 20mean% EF% BC% 89% E3% 81% AF,% E3% 81% A7 % E5% BE% 97% E3% 82% 89% E3% 82% 8C% E3% 82% 8B% E5% 80% A4% E3% 81% A7% E3% 81% 99% E3% 80% 82 & texte =% EF% BD% 81% E3% 81% A8% EF% BD% 82% E3% 81% A8% EF% BD% 83,% E3% 82% 92% E3% 81% 97% E3% 81% A6% E3 % 81% 84% E3% 81% 8D% E3% 81% BE% E3% 81% 99% E3% 80% 82)
◯ Calculez un exemple de ventes d'entreprise.
1ère année: 10 millions de yens Deuxième année: 25 millions de yens (2,5 fois l'année précédente) Troisième année: 40 millions de yens (1,6 fois l'année précédente)
En supposant que la moyenne annuelle du taux de variation des ventes soit `` geometrique_mean ''
#gmean()Fonction d'importation
from scipy.stats import gmean
# 2√ 2.5*1.6 calculer
#Géométrique la moyenne annuelle du taux de variation des ventes_Laisser signifier
geometric_mean = gmean([2.5,1.6])
print(geometric_mean)
2.0
◯Point:Scipy Une bibliothèque pour effectuer des calculs scientifiques avancés. Article de référence Utilisation de base de la bibliothèque scipy que vous devez absolument connaître
◯ ** Point **: fonction gmean () Article de référence Document officiel
◯ Il semble que la fonction ### Geometric_mean () a été introduite dans le module de statistiques de Python 3.8. Ainsi, Python 3.8 et supérieur peut l'utiliser.
from statistics import geometric_mean
print(geometric_mean([2.5,1.6]))
2.0
Document officiel: statistiques
import sympy
#Ventes(sales)Liste de
sales = [1000,2500,4000]
#Taux de changement(rate_of_change)Liste de
#Cette liste est[2.5, 1.6]devenir
rate_of_changes = [sales[i+1]/sales[i] if i < len(sales)-1 for i in range(len(sales))]
#Remplacez le produit de tous les éléments par la variable mul
#Tout d'abord, affectez le premier élément de la liste de taux de changement à la variable mul
#À ce stade, mul= 2.Devenir 5
mul = rate_of_changes[0]
#Multipliez les éléments
for i in range(len(rate_of_changes)):
#Combien de temps répéter
if i < len(rate_of_changes)-1:
#Dans la variable mul, je+Remplacer en multipliant par 1 élément
mul *= rate_of_changes[i+1]
else:
break
#root(Le contenu de l'itinéraire,~Racine)
#Le contenu de cet itinéraire est le produit de tous les éléments
geometric_mean = sympy.root(mul,len(rate_of_changes))
print('geometric_mean = ',geometric_mean)
geometric_mean = 2.00000000000000
◯ La moyenne au carré est calculée en multipliant les valeurs que vous voulez faire en moyenne au carré, en les additionnant et en divisant par le nombre d'éléments n par la racine carrée **. Il est utilisé lorsque vous souhaitez calculer la différence entre l'heure d'arrivée et l'horaire du transport.
◯ Il n'y a aucune différence dans le délai entre l'arrivée 2 minutes en retard et l'arrivée 2 minutes plus tôt. Cependant, il compense l '** erreur ** avec le ** calcul de la moyenne mathématique ** avec plus ou moins. Donc, ** carré pour éliminer le moins et ** calculer.
#root()Importez sympy pour utiliser la fonction
import sympy
#Essayez d'arrondir la valeur finale en utilisant le module décimal de la bibliothèque standard
from decimal import Decimal, ROUND_HALF_UP
#Liste des erreurs
data_list = [-2,3,4,-5]
#La nouvelle liste au carré a mis au carré chaque élément de la liste des erreurs_Créer une liste
squared_list = [i**2 for i in data_list]
#squared_Trouvez d'abord la moyenne de la liste(Valeur totale/Nombre d'éléments)
mean_square = sum(squared_list)/len(squared_list)
#mean_Prenez la racine carrée du carré
root_mean_square = sympy.root(mean_square,2)
print('RMS = ',root_mean_square)
#Str pour traiter exactement comme un type décimal de cette valeur()Convertir le type avec
#Decimal('Nombre de chiffres que vous souhaitez rechercher')Pour spécifier le chiffre
#ROUND_HALF_Effectuer un arrondi général avec UP
print('Rounded RMS = ',Decimal(str(root_mean_square)).quantize(Decimal('0.1'), rounding=ROUND_HALF_UP))
RMS = 3.67423461417477
Rounded RMS = 3.7
◯Point:Decimal.quantize Article de référence Round round and Decimal.quantize with Python
◯ La moyenne harmonisée est utilisée pour trouver la valeur moyenne de la vitesse par heure.
◯ À titre d'exemple, trouvez la vitesse moyenne lorsqu'une voiture parcourt 200 km sur l'itinéraire aller à 80 km / h et 200 km sur l'itinéraire retour à 30 km / h. La vitesse est la distance / heure, et la vitesse moyenne est calculée par ** distance totale / temps total **. ** Distance totale ** est 200 + 200 = 400 (km) ** Temps total ** (distance / vitesse) est de 200/80 + 200/30 = 2,5 (heures) + 6,666 (heures) = 9,166 (heures) ** Vitesse moyenne ** = Distance totale / Temps total = 400 / 9,166 = 43,636 (km / heure)
import statistics
#harmonic_mean([x1,x2,...xn])
print(statistics.harmonic_mean([80,30]))
43.63636363636363
distance = 200
#Trouvez la distance totale en utilisant la distance
total_distance = distance* 2
#Préparez une liste contenant les valeurs de vitesse
speed_list = [80,30]
#Temps requis pour chacun à partir de la vitesse de la liste(distance/la vitesse)Pour obtenir et lister
time_list = [distance/speed for speed in speed_list]
#Valeur totale de chaque temps requis(Temps total)Cherchant
total_time = sum(time_list)
#Harmonie moyenne=Distance totale/Temps total
harmonic_mean = total_distance/total_time
print('harmonic_mean = ',harmonic_mean)
harmonic_mean = 43.63636363636363
◯ ** Point **: article de référence Signification et méthode de calcul de la moyenne harmonieuse
◯ La valeur médiane lorsque les données sont classées par ordre croissant ou décroissant est appelée valeur médiane. Lorsque le nombre de données est pair, le nombre au milieu est de deux, donc les ajouter et les diviser par deux est la valeur médiane. L'avantage de la valeur médiane est qu'elle est moins sensible aux valeurs aberrantes (valeurs extrêmement éloignées).
◯ Il n'est pas nécessaire de faire la distinction entre les nombres pairs et impairs d'éléments.
#median()Importer un module pour utiliser une fonction
import statistics
#Le nombre d'éléments de la liste est impair
numbers = [1,100,4,7,3]
#Médiane variable_of_Remplacez la valeur médiane par nombre
#Accès à l'aide de points pour utiliser les fonctions du module
median_of_numbers = statistics.median(numbers)
print('median of numbers = ',median_of_numbers)
median of numbers = 4
◯ Nous considérerons les cas selon que le nombre d'éléments est pair ou impair. S'il est impair, trouvez l'index du nombre au milieu des éléments par ** nombre d'éléments // 2 ** (division d'entiers). S'il est pair, le nombre au milieu des éléments Deux indices sont calculés par ** nombre d'éléments / 2 ** et ** nombre d'éléments / 2-1 **.
#Le nombre d'éléments dans la liste est pair
numbers = [1,100,4,7,3,8]
#Triez d'abord la liste par ordre croissant
numbers.sort()
#Longueur variable_of_Remplacez le nombre d'éléments dans la liste des nombres par des nombres
length_of_numbers = len(numbers)
#Si le nombre d'éléments est impair
if(length_of_numbers % 2 == 1):
#Médiane variable_Attribuer un index à l'index de la valeur médiane de l'élément de liste
#Par exemple, l'indice de la valeur médiane dans une liste de 5 éléments est 5//2 = 2
median_index = length_of_numbers//2
print('median of numbers = ',numbers[median_index])
#Si le nombre d'éléments est pair
else:
#Médiane variable avec une valeur égale à la moitié du nombre d'éléments de la liste_Attribuer à l'index
median_index = length_of_numbers//2
#La valeur médiane lorsque le nombre d'éléments est pair est la somme des deux valeurs médianes et divisée par deux.
#Par exemple, lorsque le nombre d'éléments est 6, l'index avec la valeur médiane est 6/2-1 =2 et 6/2 = 3
print('median of numbers = ',(numbers[median_index-1] + numbers[median_index])/2)
#(4 + 7)/2 = 5.5
median of numbers = 5.5
◯ Trouvez l'élément qui apparaît le plus fréquemment dans la liste.
#Importer la classe Counter depuis le module collections
from collections import Counter
medals = ['gold','silver','gold','silver','silver','bronze']
#Génération d'instance
medal_counter = Counter(medals)
print(medal_counter)
Counter({'silver': 3, 'gold': 2, 'bronze': 1})
◯ ** Point **: Comment utiliser la classe
Une classe est une collection de champs et de méthodes associés.
Cependant, la classe elle-même est abstraite et ne peut pas être utilisée directement dans votre programme.
Alors, tout d'abord, rendez la classe concrète et créez l'objet.
Cette fois, Counter (médailles) '' est ça. Cela s'appelle une instance. Lorsque vous traitez cela dans le programme, traitez-le comme une variable. Pour ce faire, assignez une instance à la variable medal_countercomme medal_counter = Counter (medals) ''.
◯Point:most_common() Une méthode de la classe Counter. Renvoie tous les éléments dans l'ordre décroissant. Si un entier est spécifié comme argument, seul ce nombre sera affiché en partant du haut. (Exemple)
print(medal_counter.most_common(1))
[('silver', 3)]
◯ Créez un programme au cas où il y aurait plusieurs valeurs les plus fréquentes. Vous définissez votre propre ** fonction qui renvoie une liste des valeurs les plus fréquentes **.
#Importer la classe Counter
from collections import Counter
#Une fonction auto-conçue qui renvoie une liste des valeurs les plus fréquentes(mode_func)Définir
def mode_func(letters):
#Première lettre(lettre)Et obtenir son apparence compte
#letter_counter = Counter({'t': 2, 'o': 2, 'e': 1, 'x': 1, '_': 1, 'b': 1, 'k': 1})
letter_counter = Counter(letters)
#Ensuite, obtenez une liste de caractères et leur ensemble d'occurrences dans l'ordre décroissant, et la lettre variable_and_Attribuer pour compter
#[('t', 2), ('o', 2), ('e', 1), ('x', 1), ('_', 1), ('b', 1), ('k', 1)]
letter_and_count = letter_counter.most_common()
#Je les ai arrangés par ordre décroissant, donc"Nombre d'apparitions de l'élément le plus à gauche"(Ici 2)Est confirmée comme l'une des valeurs les plus fréquentes
#Faites-en une variable max_Attribuer pour compter
max_count = letter_and_count[0][1]
#Créez une liste pour stocker les valeurs les plus fréquentes et ajoutez d'autres éléments avec le même nombre d'occurrences si nécessaire.
mode_list = []
for letter in letter_and_count:
#Si l'élément(lettre)Si le nombre d'occurrences de est le même que celui de la valeur la plus fréquente
if letter[1] == max_count:
#Ajouter ce caractère à la liste des valeurs les plus fréquentes
mode_list.append(letter[0])
#Renvoie enfin une liste des valeurs les plus fréquentes
return(mode_list)
#Écrivez-le pour faciliter la réutilisation de la fonction
if __name__ == '__main__':
#Attribuer une liste de chaînes aux lettres variables
letters = list('text_book')
#mode_func()La liste retournée par le mode variable_Attribuer à la liste
mode_list = mode_func(letters)
#mode_Il peut y avoir plusieurs valeurs les plus fréquentes dans la liste, alors extrayez-les toutes et écrivez-les.
for mode in mode_list:
print('Mode = ',mode)
Mode = t
Mode = o
◯Point:if __name__ == '__main__':
Article de référence
Répondez à ce qu'est le ʻif name == '__ main __' `de Python
Merci pour la lecture. La prochaine fois, j'écrirai sur le calcul des statistiques de base Part3 (variation, moyenne standard ...). Je vous serais reconnaissant de bien vouloir signaler toute erreur ou amélioration.