Lors de la création d'une fonction en Python, définissez-la comme suit.
#Exemple: x^Fonction pow1 qui sort 2(x)
def pow1(x):
return x ** 2
#Les fonctions anonymes (expressions lambda) peuvent être utilisées ici pour simplifier le code.
# pow1(x)Fonction anonyme pow2 qui a la même fonction que
pow2 = lambda x: x ** 2
#En utilisant une expression lambda, vous pouvez stocker l'expression dans une variable appelée pow2.
La structure de l'expression lambda est la suivante, ce qui signifie que le pow2 ci-dessus est renvoyé avec l'argument x comme x ** 2.
argument lambda:Valeur de retour
Lorsque vous passez un argument à l'expression lambda et que vous le calculez réellement, vous pouvez l'utiliser de la même manière que la fonction créée par def en spécifiant simplement comme suit.
#Passez l'argument a à pow2 et stockez le résultat du calcul dans b
b = pow2(a)
Si vous souhaitez créer une fonction à plusieurs variables avec une expression lambda, écrivez comme suit.
#Exemple:Fonction qui ajoute deux arguments add1
add1 = lambda x, y: x + y
les expressions lambda peuvent être stockées dans des variables Il peut être utilisé sans le stocker dans une variable. Par exemple, si vous souhaitez obtenir directement le résultat de la substitution de deux arguments 3 et 5 dans l'expression lambda de add1 ci-dessus. Décrivez comme suit.
(lambda x, y: x + y)(3, 5)
#Résultat de sortie
8
Cela n'a ajouté que beaucoup de travail, mais "stocker dans une variable" = "nom et définir la fonction" Ne pas avoir à faire cela rend la fonction très facile à utiliser.
Contrairement à la fonction par def, lambda ne peut spécifier qu'une expression dans la partie valeur de retour. Par exemple, le traitement suivant était possible avec la fonction par def, mais cela ne peut pas être exprimé par lambda.
# "hello."Fonction à sortir
def say_hello():
print("hello.")
Cependant, le branchement conditionnel utilisant if peut être créé avec lambda en utilisant une technique appelée opérateur ternaire (opérateur conditionnel).
#Une fonction qui multiplie 2 si l'argument x est inférieur à 3, se divise par 3 s'il est égal ou supérieur à 3 et ajoute 5.
def lower_three1(x):
if x < 3:
return x * 2
else:
return x/3 + 5
#La fonction ci-dessus peut être exprimée en lambda comme ceci.
# lower_Même fonction que trois1
lower_three2 = lambda x: x * 2 if x < 3 else x/3 + 5
La notation de l'opérateur ternaire est la suivante.
C'est un peu déroutant
Traitement lorsque les conditions sont remplies si condition Traitement lorsque la condition else n'est pas remplie
De cette manière, l'utilisation de l'opérateur ternaire peut être utilisée dans diverses situations autres que lambda. Vous pouvez enregistrer le nombre de lignes de code.
Si vous souhaitez diviser la chaîne avec des espaces ou des barres obliques Utilisez la fonction split (). La chaîne divisée par la fonction split () est renvoyée sous forme de type liste.
Chaîne de caractères que vous souhaitez fractionner.split("Délimiteur",Nombre de divisions)
Par exemple, vous pouvez diviser une phrase en anglais avec un espace pour créer une liste de mots.
#Chaîne de caractères que vous souhaitez fractionner
test_sentence = "this is a test sentence."
#Liste avec division
test_sentence.split(" ")
#Résultat de sortie
['this', 'is', 'a', 'test', 'sentence.']
Si vous spécifiez le nombre de divisions dans l'argument, la chaîne de caractères est divisée par le nombre spécifié depuis le début. Si le nombre de fois spécifié est dépassé, aucune autre division ne sera effectuée.
#Chaîne de caractères que vous souhaitez fractionner
test_sentence = "this/is/a/test/sentence."
#Liste avec division
test_sentence.split("/", 3)
#Résultat de sortie
['this', 'is', 'a', 'test/sentence.']
La fonction standard split () ne peut pas être divisée par plusieurs symboles à la fois. Pour diviser une chaîne par plusieurs symboles à la fois
du module re
re.split()Utilisez une fonction.
La fonction re.split () vous permet de spécifier plusieurs symboles dans [] de [Séparateur]. Il est possible de diviser par plusieurs symboles à la fois.
re.split("[Délimiteur]",Chaîne de caractères que vous souhaitez fractionner)
#import re module
import re
#Chaîne de caractères que vous souhaitez fractionner
test_sentence = "this,is a.test,sentence"
# ","Quand" "Quand"."Divisez avec et faites une liste
re.split("[, .]", test_sentence)
#Résultat de sortie
['this', 'is', 'a', 'test', 'sentence']
Une fonction qui prend une autre fonction comme argument
C'est ce qu'on appelle une fonction d'ordre supérieur
Si vous souhaitez appliquer une fonction à chaque élément de la liste
map()Utilisez une fonction.
#Itérateur(Méthode de calcul du magasin)Ne calculez pas
map(Fonction que vous souhaitez appliquer,Tableau)
#Renvoie le résultat du calcul à la liste
list(map(une fonction,Tableau))
Par exemple, pour obtenir la valeur absolue de chaque élément du tableau a = [1, -2, 3, -4, 5], utilisez la boucle for et écrivez comme suit.
a = [1, -2, 3, -4, 5]
#Appliquer la fonction dans la boucle for
new = []
for x in a:
new.append(abs(x))
print(new)
#Résultat de sortie
[1, 2, 3, 4, 5]
#Cartographier ceci()En utilisant la fonction, il est possible d'écrire de manière concise comme suit.
a = [1, -2, 3, -4, 5]
#Appliquer la fonction avec la carte
list(map(abs, a))
#Résultat de sortie
[1, 2, 3, 4, 5]
##Commencer par des fonctions universelles telles que les abdominaux
##Jeu variable en lambda(Les fonctions sont également valides)
En l'enfermant dans la fonction list () Le résultat de l'application de la fonction map () (le résultat de l'application d'abs dans l'exemple ci-dessus) Vous pouvez à nouveau le stocker dans la liste.
À ce stade, si vous définissez simplement list = dans le nom de la variable J'ai l'intention d'appeler la fonction list (), mais la valeur est stockée dans la liste des variables. Veuillez noter qu'une erreur se produira.
Une classe qui a la capacité de récupérer plusieurs éléments en séquence. En utilisant cette fonction pour récupérer les éléments dans l'ordre, plutôt qu'en utilisant une boucle for Parce que le temps d'exécution peut être raccourci Si vous souhaitez appliquer une fonction à un tableau avec un grand nombre d'éléments, utilisez la fonction map ().
filter
Extraire uniquement les éléments qui satisfont aux conditions de chaque élément de la liste
filter()Utilisez une fonction.
#Renvoie un itérateur
filter(Fonction conditionnelle,Tableau)
#Renvoie le résultat du calcul à la liste
list(filter(une fonction,Tableau))
#La fonction conditionnelle est lambda x: x>Vrai pour une entrée comme 0/Une fonction qui renvoie False.
#Par exemple
a = [1, -2, 3, -4, 5]
#Pour obtenir un élément positif du tableau, utilisez la boucle for et écrivez comme suit.
a = [1, -2, 3, -4, 5]
#Filtrage avec boucle for
new = []
for x in a:
if x > 0:
new.append(x)
print(new)
#Résultat de sortie
[1, 3, 5]
#Si vous l'utilisez comme filtre, vous pouvez l'écrire de manière concise comme suit.
a = [1, -2, 3, -4, 5]
#Filtrer avec filtre
list(filter(lambda x: x>0, a))
#Résultat de sortie
[1, 3, 5]
sotred
Il existe une fonction sort () pour trier la liste, mais si vous voulez trier selon des conditions plus compliquées
sorted()Utilisez une fonction.
#Définir une clé et trier
sorted(Le tableau que vous souhaitez trier, key=Fonctions clés, reverse=Vrai ou faux)
#Pour la fonction clé, spécifiez l'élément utilisé pour le tri.
#Ici lambda x: x[n]En spécifiant, le tri est effectué en fonction du nième élément.
#Définissez reverse sur True pour trier par ordre décroissant.
#Par exemple, un tableau qui a deux éléments comme élément(Tableau imbriqué)sur
#Si vous souhaitez trier le deuxième élément de chaque élément par ordre croissant, écrivez comme suit.
#Tableau imbriqué
nest_list = [
[0, 9],
[1, 8],
[2, 7],
[3, 6],
[4, 5]
]
#Trier par le deuxième élément comme clé
sorted(nest_list, key=lambda x: x[1])
#Résultat de sortie
[[4, 5], [3, 6], [2, 7], [1, 8], [0, 9]]
Parce que la fonction map () est à l'origine spécialisée dans la création d'itérateurs Il faut du temps pour générer un tableau avec la fonction list (). Par conséquent, si vous souhaitez simplement générer un tableau en utilisant la même méthode que la fonction map (), pour boucle
Utiliser la notation d'inclusion de liste
[Fonction que vous souhaitez appliquer(élément) for élément in 適用する元の配列]
#Par exemple
a = [1, -2, 3, -4, 5] #Pour prendre la valeur absolue de chaque élément du tableau, écrivez comme suit.
a = [1, -2, 3, -4, 5]
#Prendre la valeur absolue de chaque élément dans la notation d'inclusion de liste
[abs(x) for x in a]
#Résultat de sortie
[1, 2, 3, 4, 5]
#Carte comme ci-dessous()On peut dire qu'il est plus simple d'écrire en regardant le nombre de parenthèses qu'en utilisant une fonction.
#Créer une liste avec carte
list(map(abs, a))
#Résultat de sortie
[1, 2, 3, 4, 5]
#Carte lors de la création d'un itérateur()une fonction
#Si vous souhaitez obtenir le tableau directement, il est préférable de l'utiliser correctement avec la notation d'inclusion de liste.
Lorsque le branchement conditionnel est effectué dans la notation d'inclusion de liste Vous pouvez effectuer la même opération que la fonction filter (). Comment utiliser le suffixe if est comme suit.
[Fonction que vous souhaitez appliquer(élément) for élément in フィルタリングしたい配列 if 条件]
Si vous souhaitez simplement récupérer des éléments qui remplissent les conditions Décrivez la partie de (fonction (élément) que vous souhaitez appliquer) en tant que (élément).
#Par exemple
a = [1, -2, 3, -4, 5] #Pour extraire les éléments positifs du tableau, écrivez comme suit.
a = [1, -2, 3, -4, 5]
#Filtrage d'inclusion de liste(Postfix si)
[x for x in a if x > 0]
#Résultat de sortie
[1, 3, 5]
Notez qu'il est différent de l'opérateur ternaire introduit dans lambda.
L'opérateur ternaire s'applique également aux éléments qui ne remplissent pas les conditions
Là où certains traitements doivent être définis
Lors de l'ajout de if, il est possible d'ignorer les éléments qui ne remplissent pas les conditions.
Si vous souhaitez boucler plusieurs tableaux en même temps
zip()Utilisez une fonction.
#Par exemple
a = [1, -2, 3, -4, 5], b = [9, 8, -7, -6, -5]
#Si vous souhaitez boucler le tableau en même temps, utilisez l'instruction for et écrivez comme suit.
a = [1, -2, 3, -4, 5]
b = [9, 8, -7, -6, -5]
#Boucle parallèle utilisant zip
for x, y in zip(a, b):
print(x, y)
#Résultat de sortie
1 9
-2 8
3 -7
-4 -6
5 -5
#De même pour la notation d'inclusion de liste, zip()Il est possible de traiter plusieurs tableaux en parallèle à l'aide de fonctions.
a = [1, -2, 3, -4, 5]
b = [9, 8, -7, -6, -5]
#Processus en parallèle avec la notation d'inclusion de liste
[x**2 + y**2 for x, y in zip(a, b)]
#Résultat de sortie
[82, 68, 58, 52, 50]
J'ai utilisé la fonction zip () pour boucler en même temps Faites plus de boucles à l'intérieur de la boucle
Plusieurs boucles sont écrites comme suit dans l'instruction for.
a = [1, -2, 3]
b = [9, 8]
#Double boucle
for x in a:
for y in b:
print(x, y)
#Résultat de sortie
1 9
1 8
-2 9
-2 8
3 9
3 8
#De même, dans la notation d'inclusion de liste, écrire simplement l'instruction for deux fois côte à côte crée une double boucle.
a = [1, -2, 3]
b = [9, 8]
#Double boucle dans la notation d'inclusion de liste
[[x, y] for x in a for y in b]
#Résultat de sortie
[[1, 9], [1, 8], [-2, 9], [-2, 8], [3, 9], [3, 8]]
defaultdict
Objets de type dictionnaire Python Parce qu'à chaque fois que vous ajoutez une nouvelle clé, vous devez initialiser cette clé Le processus devient compliqué.
Par exemple, le numéro de chaque élément de la liste lst Le programme à refléter dans le dictionnaire d est le suivant.
Parce qu'une clé qui n'existe pas entraînera une "Erreur de clé" Chaque fois que vous enregistrez un nouvel élément dans d, vous devez initialiser le nombre d'éléments.
#Enregistrez le nombre d'occurrences de chaque élément dans la liste lst dans le dictionnaire d
d = {}
lst = ["foo", "bar", "pop", "pop", "foo", "popo"]
for key in lst:
#clé de d(élément)Divisez le processus selon qu'il est déjà enregistré ou non
if key in d:
#clé de d(élément)Si est enregistré
#Ajouter le nombre d'éléments
d[key] += 1
else:
#clé de d(élément)N'est pas enregistré
#Besoin d'initialiser le nombre d'éléments
d[key] = 1
print(d)
#Résultat de sortie
{'foo': 2, 'bar': 1, 'pop': 2, 'popo': 1}
Donc, dans le module collections
En utilisant la classe defaultdict
Résolvez ce problème.
La classe defaultdict est définie comme suit. Pour le type valeur, spécifiez un type de données tel que int ou liste.
from collections import defaultdict
d = defaultdict(type de valeur)
defaultdict peut être utilisé comme un type de dictionnaire Si vous écrivez un programme qui effectue le même traitement que ci-dessus avec defaultdict, ce sera comme suit. Vous pouvez voir que le nombre d'éléments peut être compté sans initialiser la valeur.
from collections import defaultdict
#Enregistrez le nombre d'occurrences de chaque élément dans la liste lst dans le dictionnaire d
d = defaultdict(int)
lst = ["foo", "bar", "pop", "pop", "foo", "popo"]
for key in lst:
d[key] += 1
# else: d[key] =Pas besoin d'écrire 1 pour initialiser
print(d)
#Résultat de sortie
defaultdict(<class 'int'>, {'foo': 2, 'bar': 1, 'pop': 2, 'popo': 1})
Lors du tri de l'objet de type dictionnaire de sortie par clé ou valeur Utilisez la fonction sorted (). La fonction sorted () est
sorted(Trier la cible,Clé utilisée pour le tri,Appel au format (option de tri).
sorted(Nom du dictionnaire.items(), key=Spécifiez un tableau avec lambda, reverse=True)
La clé utilisée pour le tri est extraite au format de liste (clé, valeur) en spécifiant des éléments. Lors du tri par clé, spécifiez "premier dans la liste", c'est-à-dire x [0] en lambda.
De plus, lors du tri par valeur, spécifiez «deuxième dans la liste», c'est-à-dire x [1] en lambda.
Croissant est l'option de tri par défaut, et si vous spécifiez reverse = True, elle sera dans l'ordre décroissant. Pour trier les résultats de sortie de l'exemple de programme ci-dessus par valeur dans l'ordre décroissant et la sortie, écrivez comme suit.
print(sorted(d.items(), key=lambda x: x[1], reverse=True))
Utilisez defaultdict pour ajouter un élément à un dictionnaire de type liste.
from collections import defaultdict
defaultdict(list)
Parce que la valeur est un type de liste
Nom du dictionnaire[key].append(élément)Si vous spécifiez
Vous pouvez ajouter des éléments à la valeur. Cela demande également beaucoup de travail avec un objet de type dictionnaire standard comme suit.
#Ajouter un élément de valeur au dictionnaire
d ={}
price = [
("apple", 50),
("banana", 120),
("grape", 500),
("apple", 70),
("lemon", 150),
("grape", 1000)
]
for key, value in price:
#Branche conditionnelle en raison de l'existence d'une clé
if key in d:
d[key].append(value)
else:
d[key] = [value]
print(d)
#Résultat de sortie
{'apple': [50, 70], 'banana': [120], 'grape': [500, 1000], 'lemon': [150]}
L'utilisation de defaultdict ici élimine le besoin de branchement conditionnel. En utilisant cela, vous pouvez collecter des valeurs pour chaque clé.
Counter
En plus de la classe defaultdict dans le module collections Il existe plusieurs classes de stockage de données.
La classe de compteur est la même que defaultdict Vous pouvez l'utiliser comme un objet dictionnaire, Cette classe est plus spécialisée dans le comptage des éléments.
La classe Counter est définie comme suit. Pour les données que vous souhaitez compter, par exemple, spécifiez un tableau dans lequel les mots sont décomposés, une chaîne de caractères, un dictionnaire, etc.
from collections import Counter
d = Counter(Données que vous souhaitez compter)
Avec la classe Counter Pour créer un dictionnaire avec le mot comme clé et le nombre d'occurrences comme valeur Cela peut être réalisé simplement en écrivant comme suit Que defaultdict car il n'utilise pas la boucle for Vous pouvez compter le temps d'exécution court et concis.
#Compteur d'importation
from collections import Counter
#Enregistrez le nombre d'occurrences d'éléments dans le dictionnaire
lst = ["foo", "bar", "pop", "pop", "foo", "popo"]
d = Counter(lst)
print(d)
#Résultat de sortie
Counter({'foo': 2, 'pop': 2, 'bar': 1, 'popo': 1})
La classe Counter a quelques fonctions pour vous aider à compter
most_common()La fonction renvoie un tableau d'éléments triés par fréquence dans l'ordre décroissant.
L'utilisation de la fonction most_common () est la suivante. Spécifiez un entier pour le nombre d'éléments à acquérir. Par exemple, si 1 est spécifié, l'élément le plus fréquent est renvoyé. Si rien n'est spécifié, tous les éléments seront triés et renvoyés.
#Nom du dictionnaire.most_common(Nombre d'éléments à obtenir)
#Stockez les chaînes de caractères dans Counter et comptez la fréquence d'apparition des caractères
d = Counter("A Counter is a dict subclass for counting hashable objects.")
#Organisez le plus de 5 éléments
print(d.most_common(5))
#Résultat de sortie
[(" ", 9), ("s", 6), ("o", 4), ("c", 4), ("a", 4)]
Recommended Posts