Une fonction est un bloc de code nommé qui est utilisé pour effectuer un travail spécifique. définition de la fonction def, indiquant le nom de la fonction. Lors de la définition d'une fonction, nous déterminons les noms et les positions des paramètres , et la définition de l'interface de la fonction est terminée. Pour l'appelant de la fonction, il suffit de savoir comment passer les paramètres corrects et quelle valeur la fonction renverra La logique complexe à l'intérieur de la fonction est encapsulée. je ne sais pas.
Pour effectuer une tâche spécifique définie par une fonction, appelez la fonction. Lorsque vous effectuez plusieurs fois la même tâche dans un programme, il n'est pas nécessaire d'écrire du code à plusieurs reprises pour terminer la tâche. Il vous suffit d'appeler la fonction qui exécute la tâche et de laisser Python exécuter le code.
La fonction d'ordre supérieur est appelée fonction d'ordre supérieur en anglais
Paramètres formels : informations d'achèvement de fonction nécessaires à son travail.
Paramètres réels : informations transmises à la fonction lors de l'appel de la fonction.
La définition de fonction peut contenir plusieurs paramètres formels, de sorte que l'appel de fonction peut également contenir plusieurs paramètres réels. Il existe de nombreuses façons de transmettre des paramètres réels à la fonction. Vous pouvez utiliser des paramètres de position, ce qui nécessite que l'ordre des paramètres réels soit le même que l'ordre des paramètres formels vous pouvez également utiliser un argument mot-clé ; des mots, dans lesquels chaque paramètre réel est représenté par Composé de noms et de valeurs de variables ; des listes et des dictionnaires peuvent également être utilisés.
1. Lorsque vous appelez une fonction, Python doit associer chaque paramètre réel dans l'appel de fonction à un paramètre formel dans la définition de la fonction. L'association simple est basée sur l'ordre des paramètres réels. Cette association est appelée argument de position.
2. Dans une fonction, vous pouvez utiliser n'importe quel nombre d'arguments de position selon vos besoins, et Python associera les paramètres réels dans l'appel de fonction aux paramètres formels correspondants dans la définition de la fonction dans l'ordre.
3. Lors de l'utilisation d'arguments positionnels pour appeler une fonction, si l'ordre des arguments est incorrect, le résultat ne sera pas correct.
Les arguments de mot-clé sont des paires (nom-valeur) transmises à la fonction. Vous associez le nom et la valeur directement dans l'argument, il n'y a donc aucune confusion lors de la transmission de l'argument à la fonction. Les arguments de mots clés éliminent le besoin de se soucier de l’ordre des arguments dans un appel de fonction et indiquent clairement le but de chaque valeur dans l’appel de fonction.
animal_type='hamster', pet_name='harry') |
|
>>> person('Bob', 35, city='Beijing') name: Bob age: 35 other: {'city': 'Beijing'} >>> person('Adam', 45, gender='M', job='Engineer') name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'} |
|
>>> personne('Bob', 35 ans, ville='Pékin') nom : Bob âge : 35 autres : {'ville': 'Beijing'}>>> personne('Adam', 45, genre='M', job='Ingénieur')
|
|
def calc(*numbers): sum = 0 for n in numbers: sum = sum + n * n return sum |
|
>>> calc(1, 2) 5 >>> calc() 0 |
def add_end(L=Aucun) :
|
| def calc(*numbers): somme = 0 pour n en nombres : somme = somme + n * n retourner la somme |
| >>> >5>>> calc()0 |
| >>> nums = [1, 2, 3]>>> calc(*nums)14 |
*nums signifie transmettre tous les éléments de la liste nums en tant que paramètres variables.
Pour les paramètres de mots-clés, l'appelant de la fonction peut transmettre n'importe quel paramètre de mot-clé illimité. Quant à ce qui est transmis, vous devez passer le contrôle kw à l'intérieur de la fonction.
Si vous souhaitez limiter les noms des paramètres de mots-clés, vous pouvez utiliser des paramètres de mots-clés nommés. Par exemple, seuls la ville et le travail sont acceptés comme paramètres de mots-clés. La fonction ainsi définie est la suivante :
|
|
def person(name, age, *args, city, job): print(name, age, args, city, job) |
S'il existe déjà un paramètre variable dans la définition de la fonction, le paramètre mot-clé nommé suivant n'a plus besoin d'un séparateur spécial* :
|
|
def person(name, age, *, city='Beijing', job): print(name, age, city, job) |
|
> >> person('Jack', 24, 'Beijing', 'Engineer')
|
def person(name, age, *, city='Beijing', job): print(name, age, city, job)
| tr>
Puisque le paramètre de mot-clé nommé city a une valeur par défaut, vous n'avez pas besoin de passer le paramètre city lors de l'appel :
8.2.5 Appels de fonctions équivalents
Remarque : la méthode d'appel que vous utilisez n'a pas d'importance, tant que l'appel de fonction produit le résultat souhaité. Utilisez simplement la méthode d’appel la plus simple à comprendre.
8.2.6 Fonction vide (pass)
|
def nop():
|
|
>>> r = move(100, 100, 60, math.pi / 6) >>> print(r) (151.96152422706632, 70.0) |
| >>> x, y = déplacer (100, 100, 60 , math.pi / 6)>>> print(x, y)151.96152422706632 70.0 |
| >>> r = move(100, 100, 60, math.pi / 6)>>> print(r) ( 151.96152422706632, 70.0) |
La valeur de retour est un tuple ! Cependant, en termes de syntaxe, les parenthèses peuvent être omises lors du retour d'un tuple, et plusieurs variables peuvent recevoir un tuple en même temps et attribuer les valeurs correspondantes en fonction de la position. Par conséquent, la fonction Python renvoie plusieurs valeurs. renvoie en fait un tuple, mais il est plus pratique d'écrire .
Utilisez l'instruction if pour déterminer si ce paramètre réel est nécessaire.
La fonction peut renvoyer tout type de valeur, y compris des structures de données plus complexes telles que des listes et des dictionnaires.
En plus d'accepter des fonctions comme paramètres, les fonctions d'ordre supérieur peuvent également renvoyer des fonctions comme valeurs de résultat. Si vous n'avez pas besoin de faire la somme immédiatement, vous ne pouvez pas renvoyer le résultat de la sommation, mais renvoyer la fonction de sommation :
ax = 0
ax = ax + n return ax
return sum |
> ;> f = lazy_sum(1, 3, 5, 7, 9)
|
|
def count(): def f(j): def g(): return j*j return g fs = [] for i in range(1, 4): fs.append(f(i)) # f(i)立刻被执行，因此i的当前值被传入f() return fs >>> f1, f2, f3 = count() >>> f1() 1 >>> f2() 4 >>> f3() 9 |
| >>> f()25 |
| >>> ;>> f2 = lazy_sum(1, 3, 5, 7, 9)>>> > |
| def get_formatted_name(first_name, last_name): """Renvoyer le joli nom""" full_name = first_name + ' " + last_name return full_name.title() while True : print("nVeuillez me dire votre nom :") print("(entrez 'q' à tout moment pour quitter)") f_name = input("Prénom : ") if f_name == 'q' : break l_name = input("Nom : " ) si l_name == 'q' : break formatted_name = get_formatted_name(f_name, l_name) print("nBonjour, " + formatted_name + "!") |
| def count(): def f(j) : def g() : return j*j return g fs = [] pour i dans la plage ( 1, 4): fs.append(f(i)) # f(i) est exécuté immédiatement, donc la valeur actuelle de i est transmise dans f()return fs>>> f1, f2, f3 = compte()>>> > ;> f2()4>>> f3()9 |
Lorsque nous transmettons une fonction, parfois nous n'avons pas besoin de définir explicitement la fonction. Il est plus pratique de transmettre directement la fonction anonyme.
En Python, la prise en charge des fonctions anonymes est limitée. Toujours en prenant comme exemple la fonction map(), lors du calcul de f(x)=x2, en plus de définir une fonction de f(x), vous pouvez aussi passer directement une fonction anonyme :
|
|
def f(x):
|
pour le nom dans les noms : Vous trouverez souvent utile de passer une liste à une fonction. Cette liste peut contenir des noms, des nombres ou des objets plus complexes. . (comme un dictionnaire). Une fois qu'une liste est transmise à une fonction, celle-ci peut accéder directement à son contenu. Utilisez les fonctions ci-dessous pour améliorer l’efficacité du traitement des listes.
1. Après avoir transmis la liste à la fonction, la fonction peut la modifier. Toute modification apportée à cette liste au sein de la fonction est permanente, vous permettant de traiter efficacement de grandes quantités de données.
2. Ajouter ou supprimer un ajout pop
3. Une fonction termine une tâche et les fonctions peuvent s'appeler. Optimiser les fonctions pour faciliter la maintenance et la modification.
Pour résoudre ce problème, vous pouvez transmettre ainsi une copie de la liste à la fonction à la place de l'original, les éventuelles modifications apportées ; par la fonction n'affectera que la copie et pas du tout l'original.
function_name(list_name[:]), [:] équivaut à une copie.
Parfois, vous ne savez pas à l'avance combien de paramètres réels une fonction doit accepter. Heureusement, Python permet à la fonction de collecter. n'importe quel nombre de paramètres réels de l'instruction appelante. Le nombre d'arguments.
def make_pizza(*toppings):
L'astérisque dans le nom du paramètre *toppings indique à Python de créer un tuple vide nommé toppings et d'encapsuler toutes les valeurs reçuesdans ce tuple. L'instruction print à l'intérieur du corps de la fonction génère une sortie pour démontrer que Python peut gérer l'appel de la fonction avec une valeur, ainsi que l'appel de la fonction avec trois valeurs. Il gère les différents appels de la même manière. Notez que Python encapsule les arguments dans un tuple, même si la fonction ne reçoit qu'une seule valeur.
Si vous souhaitez qu'une fonction accepte différents types d'arguments, vous devez inclure n'importe quel nombre de paramètres formels dans la définition de la fonction. Python fait d'abord correspondre les arguments de position et les arguments de mots-clés, puis collecte les arguments restants dans le dernier paramètre formel.
Def build_profile(first, last, **user_info) :
Exigences de définition de la fonction build_profile() Fournit un premier et nom de famille, tout en permettant à l'utilisateur de fournir autant de paires nom-valeur qu'il le souhaite. Les deux astérisques dans le paramètre **user_info indiquent à Python de créer un dictionnaire vide nommé user_info et d'encapsuler toutes les paires nom-valeur reçues dans ce dictionnaire. Dans cette fonction, les paires nom-valeur dans user_info sont accessibles comme n'importe quel autre dictionnaire.
pour la clé, valeur dans user_info.items():
profile[key] = value
user_profile = build_profile('albert', 'einstein',location=' princeton', field='physics')
1. Définissez des fonctions en Python, vous pouvez utiliser les paramètres requis, les paramètres par défaut, les paramètres variables, les paramètres de mots-clés et les paramètres nommés. Paramètres de mots-clés, ces cinq paramètres peuvent être utilisés en combinaison. Mais veuillez noter que l'ordre de définition des paramètres doit être : Paramètres requis, paramètres par défaut, paramètres variables, paramètres de mots-clés nommés et paramètres de mots-clés.
2. Les fonctions Python ont une forme de paramètre très flexible, qui peut non seulement implémenter des appels simples, mais également transmettre des paramètres très complexes.
3. Les paramètres par défaut doivent utiliser des objets immuables. S'il s'agit d'objets variables, il y aura des erreurs logiques lors de l'exécution du programme !
4. Faites attention à la syntaxe de définition des paramètres de variable et des paramètres de mot-clé :
5. *args est un paramètre variable, et args reçoit un tuple
6 . **kw est un paramètre de mot-clé et kw reçoit un dict.
7. Et la syntaxe de la façon de transmettre des paramètres de variable et des paramètres de mot-clé lors de l'appel d'une fonction :
Les paramètres de variable peuvent être transmis directement : func(1, 2, 3), ou Vous pouvez d'abord assembler la liste ou le tuple, puis le transmettre via *args: func(*(1, 2, 3));
Les paramètres du mot clé peuvent être transmis directement : func(a=1) , b=2 ), vous pouvez d'abord assembler le dict, puis le transmettre via **kw: func(**{'a': 1, 'b': 2}).
Utiliser *args et **kw est l'idiome de Python. Bien sûr, d'autres noms de paramètres peuvent également être utilisés, mais il est préférable d'utiliser l'idiome.
Au sein d'une fonction, vous pouvez appeler d'autres fonctions. Si une fonction s'appelle à l'intérieur de , la fonction est récursive. Les avantages des fonctions récursives sont une définition simple et une logique claire. Théoriquement, toutes les fonctions récursives peuvent être écrites dans une boucle, mais la logique des boucles n'est pas aussi claire que la récursivité.
|
Lors de l'utilisation de fonctions récursives, il faut veiller à éviter le débordement de pile. Dans les ordinateurs, les appels de fonction sont implémentés via la structure de données de la pile Chaque fois qu'un appel de fonction est saisi, un cadre de pile est ajouté à la pile. Chaque fois qu'une fonction revient, un cadre de pile est soustrait de la pile. Puisque la taille de la pile n’est pas infinie, trop d’appels récursifs entraîneront un débordement de pile.
Le mouvement de la Tour de Hanoï peut être implémenté très simplement à l'aide de fonctions récursives.
Puisque les variables peuvent pointer vers des fonctions et que les paramètres des fonctions peuvent recevoir des variables, alors une fonction peut recevoir une autre fonction En tant que paramètres, ce type de fonction est appelé fonction d'ordre supérieur.
|
|
>>> type(123) >>> type('str') >>> type(None) |
2. Pour déterminer le type d'objet, utilisez la fonction type() :
|
>>> type(123)
|
|
>>> hasattr(obj, 'x') # 有属性'x'吗？ True >>> obj.x 9 >>> hasattr(obj, 'y') # 有属性'y'吗？ False >>> setattr(obj, 'y', 19) # 设置一个属性'y' >>> hasattr(obj, 'y') # 有属性'y'吗？ True >>> getattr(obj, 'y') # 获取属性'y' 19 >>> obj.y # 获取属性'y' 19 |
|
>>> len('ABC') 3
|
| >>> hasattr(obj, 'x') # Possède des attributs « x » ? Vrai>>> obj.x9>>> Y a-t-il un attribut « y » ? Faux>>> setattr(obj, 'y', 19) # Définir un attribut 'y'>>> obj, 'y') # Y a-t-il un attribut 'y' ? Vrai>>> getattr(obj, 'y') # Obtenir l'attribut 'y'19>> > obj.y # Obtenir l'attribut 'y'19 |
| >>> >... retourner x * x...>>> 8, 9])>>> liste(r)[1, 4, 9, 16, 25, 36, 49, 64, 81] |
| >>> de functools import réduire> ;>> def fn(x, y):... Retour x * 10 + y...>>> (fn, [1, 3, 5, 7, 9])13579 |
12.La fonction filter() intégrée de Python est utilisée pour filtrer les séquences. filter() accepte également une fonction et une séquence . Contrairement à map(), filter() applique tour à tour la fonction transmise à chaque élément, puis décide de conserver ou de supprimer l'élément selon que la valeur de retour est True ou False. La clé est d’implémenter correctement une fonction « filtre ». Notez que la fonction filter() renvoie un Iterator, qui est une séquence paresseuse, donc pour forcer filter() à terminer les résultats du calcul, vous devez utiliser la fonction list() pour obtenir tous les résultats et renvoyer la liste.
|
| >>> , -21])[-21, -12, 5, 9, 36] |
|
>>> def now(): ... print('2015-3-25') ... >>> f = now >>> f() 2015-3-25 >>> now.__name__ 'now' >>> f.__name__ 'now' |
|
>>> trié(['bob', 'about', 'Zoo', 'Crédit'], key=str.lower, reverse=True)
|
| >>> def now():... print('2015-3-25')... >>> f = maintenant>>> f()25-3-2015>>> __name__ 'maintenant'>>> f.__name__'maintenant' |
| classe Étudiant(objet): @property def score(self): return self._score @score.setter def score(self, value): sinon isinstance(value, int): raise ValueError('le score doit être un entier !') si la valeur < 0 ou la valeur > 100 : raise ValueError('le score doit être compris entre 0 et 100 !') self._score = valeur |
@property est largement utilisé dans les définitions de classes, permettant aux appelants d'écrire des codes courts tout en assurant les vérifications nécessaires sur les paramètres, réduisant ainsi le risque d'erreurs lors de l'exécution du programme.
Le décorateur @unique peut nous aider à vérifier qu'il n'y a pas de valeurs en double.
Afin d'écrire du code maintenable, vous pouvez regrouper de nombreuses fonctions dans différents fichiers, de sorte que le code contenu dans chaque fichier soit relativement moindre. En Python, un fichier .py est appelé un module (Module).
L'un des avantages des fonctions est qu'elles permettent de séparer des blocs de code du programme principal. En donnant des noms descriptifs aux fonctions, vous rendez le programme principal beaucoup plus facile à comprendre. Vous pouvez aller plus loin et stocker les fonctions dans des fichiers séparés appelés modules, puis importer les modules dans le programme principal. L'instruction import permet au code du module d'être utilisé dans le fichier programme en cours d'exécution. En stockant les fonctions dans des fichiers séparés, vous pouvez masquer les détails du code du programme et vous concentrer sur la logique de haut niveau du programme. Cela vous permet également de réutiliser des fonctions dans de nombreux programmes différents. En stockant les fonctions dans des fichiers séparés, vous pouvez partager ces fichiers avec d'autres programmeurs plutôt qu'avec l'ensemble du programme. Savoir importer des fonctions vous permet également d'utiliser des bibliothèques de fonctions écrites par d'autres programmeurs. Afin d'éviter les conflits de noms de modules, Python a introduit une méthode d'organisation des modules par répertoire, appelée package. Une fois le package introduit, tant que le nom du package de niveau supérieur n'est pas en conflit avec les autres, tous les modules n'entreront pas en conflit avec les autres. Désormais, le nom du module abc.py devient mycompany.abc, de même, le nom du module xyz.py devient mycompany.xyz. Notez qu'il y aura un fichier __init__.py sous chaque répertoire de package. Ce fichier doit exister, sinon, Python traitera ce répertoire comme un répertoire normal au lieu d'un package. __init__.py peut être un fichier vide ou contenir du code Python, car __init__.py lui-même est un module et son nom de module est mycompany. 8.7.1 Importer l'intégralité du module Pour rendre la fonction importable, vous devez d'abord créer le module. Les modules sont des fichiers avec une extension .py qui contiennent du code à importer dans un programme.if __name__=='__main__' :
test() |
8.7.2 Portée
Dans un module, nous pouvons définir de nombreuses fonctions et variables, mais certaines fonctions et variables que nous espérons être utilisées par d'autres, et certaines fonctions et variables que nous espérons uniquement utilisées à l'intérieur du module. En Python, cela est réalisé grâce au préfixe _. Les noms normaux de fonctions et de variables sont publics et peuvent être directement référencés, tels que : abc, x123, PI, etc. ; les variables comme __xxx__ sont des variables spéciales et peuvent être directement référencées, mais ont des objectifs spéciaux, comme ci-dessus. Les __author__ et __name__ sont des variables spéciales. Les commentaires du document définis par le module hello sont également accessibles avec la variable spéciale __doc__. Généralement, nous ne devons pas utiliser ce nom de variable pour nos propres variables ou les variables comme _xxx et __xxx sont non publiques (privées). ne doivent pas être citées directement, comme _abc, __abc, etc. ;
|
def _private_1(name): return 'Hello, %s' % name
def _private_2(name): return 'Hi, %s' % name
def greeting(name): if len(name) > 3: return _private_1(name) else: return _private_2(name) |
| def _private_1(name): return 'Bonjour, %s' % nom def _private_2(name): return 'Bonjour, %s' % nom def salutation(nom) : si len(nom) > 3 : return _private_1(nom) else : return _private_2(name) |
Nous exposons la fonction Greeting() dans le module et masquons la logique interne avec les fonctions privées. De cette façon, lors de l'appel de la fonction Greeting(), nous n'avons pas à nous soucier des détails de la fonction privée interne. Il s'agit également d'une méthode d'encapsulation et d'abstraction de code très utile, c'est-à-dire que toutes les fonctions qui n'ont pas besoin d'être référencées de l'extérieur sont définies comme privées, et seules les fonctions qui doivent être référencées de l'extérieur sont définies comme publiques.
Stockez plusieurs fonctions dans un module, séparées par des virgules, vous pouvez importer n'importe quel nombre de fonctions depuis le module.
from pizza import make_pizza as mp
Si le nom de la fonction à importer peut entrer en conflit avec un existant nom dans le programme. Ou si le nom de la fonction est trop long, vous pouvez spécifier un alias court et unique - un autre nom pour la fonction, similaire à un surnom. Pour attribuer ce pseudo spécial à une fonction, vous devez le faire lors de son importation.
Vous pouvez également spécifier des alias pour les modules. En attribuant un alias court à un module (comme en attribuant l'alias p au module pizza), vous pouvez plus facilement appeler des fonctions dans le module. Comparé à pizza.make_pizza(), p.make_pizza() est plus concis.
L'utilisation de l'opérateur astérisque (*) permet à Python d'importer toutes les fonctions du module.
Cependant, lorsque vous utilisez un gros module que vous n'avez pas écrit vous-même, il est préférable de ne pas utiliser cette méthode d'importation : s'il y a des fonctions dans le module avec les mêmes noms que celles utilisées dans votre projet, cela peut conduire à des résultats inattendus : Python peut rencontrer plusieurs fonctions ou variables portant le même nom et écraser la fonction au lieu d'importer toutes les fonctions séparément.
Lors de l'écriture de fonctions, vous devez garder plusieurs détails à l'esprit.
1. Les fonctions doivent recevoir des noms descriptifs, en utilisant uniquement des lettres minuscules et des traits de soulignement. Les noms descriptifs vous aident, vous et les autres, à comprendre ce que le code essaie de faire. La convention ci-dessus doit également être suivie lors de la dénomination des modules.
2. Chaque fonction doit contenir un commentaire qui explique brièvement sa fonction. Le commentaire doit suivre la définition de la fonction et utiliser le format docstring . Une fonction bien documentée permet à d'autres programmeurs de l'utiliser simplement en lisant la description dans la docstring : ils peuvent être sûrs que le code fonctionnera comme décrit tant qu'ils connaissent le nom de la fonction, les arguments requis et le type de celle-ci ; la valeur de retour, ils peuvent Vous pouvez l'utiliser dans vos propres programmes.
3.Lors de la spécification d'une valeur par défaut pour un paramètre formel, il ne doit y avoir aucun espace de chaque côté du signe égal.
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
