Introduction aux bases de Python - Fonction

8. Fonction

1. 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.

2. 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.

3. La fonction d'ordre supérieur est appelée fonction d'ordre supérieur en anglais

8.1 Paramètres réels et paramètres formels

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.

8.2 Passage de paramètres

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.

8.2.1 Paramètres positionnels

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.

8.2.2 Arguments de mot-clé et paramètres de mot-clé

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.

describe_pet(animal_type='hamster', pet_name='harry')

describe_pet(

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'}

Vous pouvez transmettre n'importe quel nombre de paramètres de mots clés :

>>> personne('Bob', 35 ans, ville='Pékin')

nom : Bob âge : 35 autres : {'ville': 'Beijing'}>>> personne('Adam', 45, genre='M', job='Ingénieur')

def add_end(L=None):

    if L is None:

        L = []

    L.append('END')

    return L

nom : Adam âge : 45 autres : {'genre' : 'M', 'job' : 'Ingénieur'}

8.2.3 Valeur par défaut

Lors de l'écriture d'une fonction, vous pouvez spécifier une valeur par défaut pour chaque paramètre formel. Lorsqu'un paramètre réel est fourni pour un paramètre formel dans la fonction appelante, Python utilisera la valeur réelle du paramètre spécifiée, sinon la valeur par défaut du paramètre formel sera utilisée. Par conséquent, après avoir attribué des valeurs par défaut aux paramètres formels, les paramètres réels correspondants peuvent être omis dans l'appel de fonction. L'utilisation des valeurs par défaut simplifie les appels de fonction et indique clairement les utilisations typiques de la fonction. Le plus grand avantage est que cela peut réduire la difficulté d’appeler des fonctions.

def calc(*numbers):

    sum = 0

    for n in numbers:

        sum = sum + n * n

    return sum

Les paramètres par défaut doivent pointer vers des objets immuables !

>>> calc(1, 2)

5

>>> calc()

0

tbody>

def add_end(L=Aucun) :

>>> nums = [1, 2, 3]

>>> calc(*nums)

14

si L vaut Aucun : L = [] L.append('END') return L

8.2.4 Paramètres variables Par rapport à la définition d'un paramètre de liste ou de tuple, la définition d'un paramètre variable ne nécessite qu'un signe * devant le paramètre. À l'intérieur de la fonction, les numéros de paramètres reçoivent un tuple, le code de la fonction reste donc complètement inchangé. Cependant, lors de l'appel de cette fonction, n'importe quel nombre de paramètres peut être transmis, y compris 0 paramètre.

def calc(*numbers): somme = 0 pour n en nombres : somme = somme + n * n retourner la somme

>>> >5>>> calc()0

　Python Permet d'ajouter un signe * devant la liste ou le tuple, et de passer les éléments de la liste ou du tuple en paramètres variables :

>>> nums = [1, 2, 3]>>> calc(*nums)14

*nums signifie transmettre tous les éléments de la liste nums en tant que paramètres variables.

8.2.5 Paramètres de mots-clés nommés

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, *, city, job):

    print(name, age, city, job)

def person(name, age, *, ville, emploi) :

print(nom, âge, ville, emploi)

et paramètre de mot-clé ** kw Différemment, les paramètres de mot-clé nommé nécessitent un délimiteur spécial *, et les paramètres qui suivent * sont traités comme des paramètres de mot-clé nommé.

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* :

>>> person('Jack', 24, 'Beijing', 'Engineer')

Traceback (most recent call last):

  File "", line 1, in

TypeError: person() takes 2 positional arguments but 4 were given

def personne (nom, âge, *arguments, ville, travail) :

imprimer (nom, âge, arguments, ville, travail)

Les paramètres de mots clés nommés doivent transmettre le nom du paramètre, qui est différent des paramètres de position. Si aucun nom de paramètre n'est transmis, l'appel signalera une erreur :

def person(name, age, *, city='Beijing', job):

    print(name, age, city, job)

> >> person('Jack', 24, 'Beijing', 'Engineer')

>>> person('Jack', 24, job='Engineer')

Jack 24 Beijing Engineer

Retraçage (dernier appel le plus récent) :

Fichier "", ligne 1 , dans < module>

TypeError : person() prend 2 arguments de position mais 4 ont été donnés

Parce que le paramètre name city est manquant lors de l'appel et du job, l'interpréteur Python traite ces 4 paramètres comme des paramètres de position, mais la fonction person() n'accepte que 2 paramètres de position.

Les paramètres de mots clés nommés peuvent avoir des valeurs par défaut (valeurs par défaut), simplifiant ainsi les appels :

tr>

def person(name, age, *, city='Beijing', job):

print(name, age, city, job)

def nop():

    pass

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 :

>>> personne('Jack', 24, job='Ingénieur')

Jack 24 Ingénieur Pékin

Lors de la définition des paramètres de mots clés nommés, n'oubliez pas d'écrire le délimiteur * s'il n'y a pas de paramètres variables, sinon la définition sera positionnelle paramètres.

8.2.5 Appels de fonctions équivalents

Les résultats de sortie sont les mêmes, mais les méthodes d'appel sont différentes.

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)

Si vous souhaitez définir une fonction vide qui ne fait rien, vous pouvez utiliser l'instruction pass :

L'instruction pass ne fait rien. Pass peut être utilisé comme espace réservé. Par exemple, si vous n'avez pas encore compris comment écrire le code de la fonction, vous pouvez d'abord mettre un pass pour que le code puisse s'exécuter. .

def nop():

>>> x, y = move(100, 100, 60, math.pi / 6)

>>> print(x, y)

151.96152422706632 70.0

pass

>>> r = move(100, 100, 60, math.pi / 6)

>>> print(r)

(151.96152422706632, 70.0)

8.2.7 Éviter les erreurs de paramètres réels Aucun paramètre réel n'est donné, l'ordre réel des paramètres est erroné et le format réel des paramètres (guillemets, etc.) n'est pas pris en compte. 8.2.8 instruction globale (variable globale) Si vous souhaitez modifier la valeur stockée dans une variable globale dans une fonction, vous devez utiliser l'instruction globale pour la variable. 8.3 Valeur de retour Une fonction n'affiche pas toujours directement la sortie, elle peut traiter certaines données et renvoyer une valeur ou un ensemble de valeurs. La valeur renvoyée par une fonction est appelée valeur de retour. La valeur de retour de la fonction est renvoyée à l'aide de l'instruction return. Au sein d'une fonction, vous pouvez utiliser l'instruction return pour renvoyer une valeur à la ligne de code qui a appelé la fonction. Les valeurs de retour vous permettent de simplifier votre programme principal en déplaçant la plupart des tâches lourdes de votre programme vers des fonctions. 8.3.1 Renvoyer plusieurs valeurs L'instruction import math signifie importer le package mathématique et permet au code suivant de référencer sin, cos et d'autres fonctions dans le package mathématique. Vous pouvez renvoyer plusieurs valeurs. table> Mais en fait ce n'est qu'une illusion, la fonction Python renvoie toujours une seule valeur :

>>> 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 .

8.3.2 Rendre le paramètre réel facultatif

Utilisez l'instruction if pour déterminer si ce paramètre réel est nécessaire.

8.3.3 Retourner un dictionnaire

La fonction peut renvoyer tout type de valeur, y compris des structures de données plus complexes telles que des listes et des dictionnaires.

8.3.4 Fonction de retour

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 :

def lazy_sum(*args):

    def sum():

        ax = 0

        for n in args:

            ax = ax + n

        return ax

    return sum

def lazy_sum(*args):

def sum():

>>> f = lazy_sum(1, 3, 5, 7, 9)

>>> f

.sum at 0x101c6ed90>

ax = 0

>>> f()

25

pour n dans les arguments :

ax = ax + n

return ax

>>> f1 = lazy_sum(1, 3, 5, 7, 9)

>>> f2 = lazy_sum(1, 3, 5, 7, 9)

>>> f1==f2

False

return sum

Lorsque nous appelons lazy_sum() , ce qui est renvoyé n'est pas le résultat de la sommation, mais la fonction de sommation :

> ;> f = lazy_sum(1, 3, 5, 7, 9)

def get_formatted_name(first_name, last_name):  

            """返回整洁的姓名"""   

　　full_name = first_name + ' ' + last_name   

　　return full_name.title()

while True:   

　　print("nPlease tell me your name:")   

　　print("(enter 'q' at any time to quit)")   

　　f_name = input("First name: ")   

　　if f_name == 'q':       

　　　　break   

　　l_name = input("Last name: ")   

　　if l_name == 'q':       

　　　　break   

formatted_name = get_formatted_name(f_name, l_name)   

print("nHello, " + formatted_name + "!")

>>> f

.sum à 0x101c6ed90> ;

Lorsque la fonction f est appelée, le résultat de la somme est effectivement calculé :

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

　Remarque : Lorsque nous appelons lazy_sum(), chaque appel retournera une nouvelle fonction, même si les mêmes paramètres sont passés dans :

>>> ;>> f2 = lazy_sum(1, 3, 5, 7, 9)>>> >

　 Les résultats des appels de f1() et f2() ne s'affectent pas. 8.3.5 Utiliser des fonctions avec while

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 + "!")

8.3.6 Fermeture Une chose à garder à l'esprit lors du renvoi d'une fermeture est la suivante : la fonction de retour ne fait référence à aucune variable de boucle ou à aucune variable qui le fera. changer par la suite. Si vous devez faire référence à une variable de boucle, la méthode consiste à créer une autre fonction et à utiliser les paramètres de la fonction pour lier la valeur actuelle de la variable de boucle. Quelle que soit la façon dont la variable de boucle change par la suite, la valeur liée au paramètre de fonction sera. ne change pas. L'inconvénient est que le code est plus long, vous pouvez utiliser les fonctions lambda pour raccourcir le code.

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

8.3.7 Fonction anonyme lambda

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 :

table>

Par comparaison, on voit que la fonction anonyme lambda x: x * x est en réalité :

>>> list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))

[1, 4, 9, 16, 25, 36, 49, 64, 81]

>>> list(map(lambda x: x * x, [1, 2, 3, 4 , 5, 6, 7, 8, 9]))

[1, 4, 9, 16, 25, 36, 49, 64, 81]

def f(x):

    return x * x

def f(x):

>>> f = lambda x: x * x

>>> f

at 0x101c6ef28>

>>> f(5)

25

return x * x

Le mot clé lambda représente une fonction anonyme, le x avant les deux points représente le paramètre de la fonction. Les fonctions anonymes ont une limitation, c'est-à-dire qu'elles ne peuvent avoir qu'une seule expression. Il n'est pas nécessaire d'écrire return. La valeur de retour est le résultat de l'expression. Il y a un avantage à utiliser des fonctions anonymes, car la fonction n'a pas de nom, vous n'avez donc pas à vous soucier des conflits de noms de fonction. De plus, la fonction anonyme est également un objet fonction. Vous pouvez également affecter la fonction anonyme à une variable puis utiliser la variable pour appeler la fonction : >>> f = lambda x: x * x>>> fonction à 0x101c6ef28>>>> f(5)25

8.4 Passer une liste

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.

8.4.1 Modifier la liste dans la fonction

　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.

8.4.2 Il est interdit de modifier la fonction

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.

8.5 Passer n'importe quel nombre de paramètres réels (paramètres variables)

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çues​​dans 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.

8.5.1 Combiner des arguments positionnels et des arguments variables

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.

8.5.2 Utilisation d'arguments variables et d'arguments mots-clés

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')

8.5.3 Utilisation de combinaisons de paramètres

　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.

8.5.4 Paramètres récursifs

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é.

def fact(n):

    if n==1:

        return 1

    return n * fact(n - 1)

def fact(n): si n==1 : return 1 return n * fact(n - 1)

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.

8.6 Fonctions d'ordre supérieur

8.6.1 Fonctions d'ordre supérieur

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.

def add(x, y, f):

    return f(x) + f(y)

def add(x, y, f):

return f(x) + f(y)

8.6.2 Fonctions intégrées

1 .La fonction abs() qui trouve la valeur absolue n'a qu'un seul paramètre.

>>> type(123)

>>> type('str')

>>> type(None)

　2. Pour déterminer le type d'objet, utilisez la fonction type() :

>>> type(123)

>>> len('ABC')

3

>>> 'ABC'.__len__()

3

>>> 🎜>< ;class 'str'>

>>> type(Aucun)

　3. Pour calculer la racine carrée, vous pouvez appeler la fonction math.sqrt().

　4.lower() renvoie une chaîne minuscule.

La méthode 5.__len__ renvoie la longueur. En Python, si vous appelez la fonction len() pour essayer d'obtenir la longueur d'un objet, en fait, à l'intérieur de la fonction len(), elle appelle automatiquement la méthode __len__() de l'objet, donc le code suivant est équivalent：

>>> 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

>>> def f(x):

...     return x * x

...

>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])

>>> list(r)

[1, 4, 9, 16, 25, 36, 49, 64, 81]

>>> 'ABC'.__len__()

3

>>> from functools import reduce

>>> def fn(x, y):

...     return x * 10 + y

...

>>> reduce(fn, [1, 3, 5, 7, 9])

13579

6. La fonction max max() peut recevoir n'importe quel nombre de paramètres et renvoyer le plus grand. 7. Si vous souhaitez obtenir toutes les propriétés et méthodes d'un objet, vous pouvez utiliser la fonction dir(), qui renvoie une liste contenant des chaînes par exemple, pour obtenir toutes les propriétés et méthodes d'un. Objet str : 　8. La fonction hex() intégrée de Python convertit un entier en une chaîne représentée en hexadécimal. 9. Pour les relations d'héritage de classe, il est très gênant d'utiliser type(). Pour déterminer le type de classe, nous pouvons utiliser la fonction isinstance(). Les types de paramètres sont vérifiés et seuls les paramètres de type entier et à virgule flottante sont autorisés. La vérification du type de données peut être implémentée à l'aide de la fonction intégrée isinstance(). Utilisez la fonction isinstance intégrée pour déterminer si une variable est une chaîne. 10. Avec getattr(), setattr() et hasattr(), on peut manipuler directement l'état d'un objet.

>>> 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

Grâce à une série de fonctions intégrées, nous peut analyser n'importe quel objet Python et obtenir ses données internes. Il convient de noter que nous n’obtiendrons des informations sur l’objet que lorsque nous ne connaîtrons pas les informations sur l’objet. 11. Python a des fonctions map() et reduction() intégrées. map applique tour à tour la fonction passée à chaque élément de la séquence et renvoie le résultat en tant que nouvel itérateur.

>>> >...     retourner x * x...>>> 8, 9])>>> liste(r)[1, 4, 9, 16, 25, 36, 49, 64, 81]

Comment utiliser réduire. réduire applique une fonction à une séquence [x1, x2, x3, ...]. Cette fonction doit recevoir deux paramètres. réduire continue le résultat et effectue un calcul cumulatif avec l'élément suivant de la séquence.

>>> 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.

def is_odd(n):

    return n % 2 == 1

 

list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))

# 结果: [1, 5, 9, 15]

def is_odd(n):

return n % 2 = = 1

>>> sorted([36, 5, -12, 9, -21])

[-21, -12, 5, 9, 36]

>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)

['Zoo', 'Credit', 'bob', 'about']

list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))

# Résultat : [1 , 5, 9, 15]

13. La fonction sorted() intégrée de Python peut trier la liste.

>>> , -21])

[-21, -12, 5, 9, 36]

　14.sorted( ) est également une fonction d'ordre supérieur. Elle peut également recevoir une fonction clé pour mettre en œuvre un tri personnalisé, tel que le tri par valeur absolue. Pour effectuer un tri inversé, vous n'avez pas besoin de modifier la fonction de la clé. Vous pouvez passer le troisième paramètre reverse=True.

>>> 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)

class Student(object):

 

    @property

    def score(self):

        return self._score

 

    @score.setter

    def score(self, value):

        if not isinstance(value, int):

            raise ValueError('score must be an integer!')

        if value < 0 or value > 100:

            raise ValueError('score must between 0 ~ 100!')

        self._score = value

['Zoo', 'Crédit', 'bob', 'about']

　15. La fonction enumerate intégrée de Python peut transformer une liste en une paire index-élément, de sorte que l'index et l'élément lui-même puissent être itérés en même temps dans un pour la boucle. 16. La fonction round() peut renvoyer n'importe quelle décimale. 8.6.3 Décorateur La manière d'ajouter dynamiquement des fonctions pendant l'exécution du code est appelée "Décorateur". Essentiellement, un décorateur est une fonction d’ordre supérieur qui renvoie une fonction. Décorateur : ajoutez de nouvelles fonctionnalités sans modifier la fonction elle-même. L'objet fonction a un attribut __name__, vous pouvez obtenir le nom de la fonction : Le décorateur @property intégré de Python est chargé de transformer une méthode en appel de propriété :

>>> 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.

8.7 Stocker les fonctions dans des modules

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__' :

if __name__=='__main__':

    test()

test()

La première étape pour utiliser un module est d'importer le module Lorsque nous exécutons le fichier hello module sur la ligne de commande, l'interpréteur Python. modifie une variable spéciale __name__ est définie sur __main__, et si le module hello est importé ailleurs, le jugement if échouera. Par conséquent, ce test if permet à un module d'exécuter du code supplémentaire lors de l'exécution via la ligne de commande. exécuter un 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)

Les fonctions ou variables privées ne doivent pas être citées par d'autres, alors à quoi servent-elles ? Veuillez consulter l'exemple :

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.

8.7.3 Importer des modules spécifiques

Stockez plusieurs fonctions dans un module, séparées par des virgules, vous pouvez importer n'importe quel nombre de fonctions depuis le module.

8.7.4 Utiliser as pour spécifier un alias pour une fonction

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.

8.7.5 Utiliser as pour spécifier des alias pour les modules

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.

8.7.6 Utilisez * pour importer toutes les fonctions du module

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.

8.8 Guide d'écriture de fonctions

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!