Bases des fonctions (python)

Le contenu de cet article est la connaissance de base des fonctions Python. Maintenant, je le partage avec vous. Les amis dans le besoin peuvent se référer au contenu de l'article

Fonction : si vous avez besoin d'un certain morceau de code plusieurs fois lors du développement d'un programme, mais afin d'améliorer l'efficacité de l'écriture et la réutilisation du code, les blocs de code avec des fonctions indépendantes sont organisés en un petit module
Ceci est une fonction

Définition et appel de la fonction

<1>Définir la fonction
Le format de définition de la fonction est le suivant :

def function name():
Code
< 2>Appelez la fonction

Après avoir défini la fonction, cela équivaut à avoir un code avec certaines fonctions. Si vous souhaitez que ces codes soient exécutés, vous devez l'appeler
L'appel de la fonction est très simple , l'appel peut être complété via le nom de la fonction ()


Paramètres de la fonction (1)

Afin de rendre une fonction plus générale, c'est-à-dire , si vous voulez qu'il calcule la somme de deux nombres, laissez-le simplement calculer la somme de ces deux nombres. Lors de la définition de la fonction, vous pouvez laisser la fonction recevoir des données
résout ce problème. function

<1> Définir avec des paramètres Fonction

Les exemples sont les suivants :

def add2num(a, b):
c = a+b
print c

<2> Appel avec les fonctions de paramètre

Prenons l'exemple de l'appel de la fonction add2num(a, b) :


def add2num( a, b):
c = a+b
Print C

add2num (11, 22) #Lors de l'appel d'une fonction avec des paramètres, vous devez transmettre les données
& lt; 4 & gt; Les paramètres entre parenthèses servent à recevoir des paramètres et sont appelés "paramètres formels"

Les paramètres entre parenthèses lors de l'appel servent à passer à la fonction sont appelés "paramètres réels"

Valeur de retour de la fonction (1)

<1> Introduction à la "valeur de retour"

La soi-disant "valeur de retour" est la valeur finale donnée à l'appelant après la fonction dans le le programme termine une chose Résultat

<2>Fonction avec valeur de retour

Si vous souhaitez renvoyer le résultat à l'appelant dans la fonction, vous devez utiliser return

dans la fonction comme suit :

def add2num(a, b):
c = a+b
return c

ou

def add2num(a , b):
Return a+b

<3>Enregistrer la valeur de retour de la fonction

Dans l'exemple "acheter des cigarettes" mentionné au début de cette section, à la fin ton fils te donne des cigarettes Quand, tu as dû les prendre à ton fils, non ? La même chose est vraie pour les programmes Si une fonction renvoie une donnée, et que tu veux utiliser cette donnée, tu dois la sauvegarder
.
Un exemple de la valeur de retour de la fonction enregistrée est le suivant :

             #Define function
                                                                                                                                                                                                                                                                   100,98)

                                                                        utiliser en utilisant                         ‐ ' ' ' ' s off 100, 98) >


Valeur de retour de la fonction (2)
Pouvons-nous renvoyer plusieurs valeurs en python ?

                                                                               shang, yushu
...
>>& gt; ch, yu = pid(5, 2)
>>> > >>> ; yu
1

L'essence est d'utiliser le tuple



4 types de fonctions

La fonction dépend sur s'il y a des paramètres et s'il y a un retour Les valeurs peuvent être combinées entre elles. Il existe 4 types au total

.Aucun paramètre, aucune valeur de retour
                                        ' ' ' ' ' ' '                                                                                      à

Ce type de fonction ne peut pas accepter de paramètres et n'a aucune valeur de retour. Généralement, pour imprimer des fonctions similaires aux voyants d'invite. , utilisez ce type de fonction

<2>Aucun paramètre, valeur de retour Fonction valeur

Ce type de fonction ne peut pas recevoir de paramètres, mais peut renvoyer certaines données. Généralement, pour collecter des données, utilisez. ce type de fonction


>                def getTemperature():

                                                                                                                                                                                                                                              🎜>
température = getTemperature()
                                                                                                                                                                                                                                                               La température actuelle est : 24 Fonctions avec paramètres et sans retour valeurs

Ce type de fonction peut recevoir des paramètres, mais ne peut pas renvoyer de données. Généralement, ce type de fonction est utilisé lors de la définition de données pour certaines variables sans exiger de résultats.                                                                                                                                                                Fonctions avec paramètres et retour valeurs

                          , utilisez ce type de fonction


                # Calculer la somme cumulée de 1~num                                                                                                                            def calculateNum(num):     1
tandis que i<=num :

result = result + i

i+=1

return result

result = calculateNum(100)
print( 'La somme cumulée de 1 ~100 est : %d'%result)

Résultat :

La somme cumulée de 1~100 est : 5050

Paramètres de fonction (2)<参> 1. Paramètres par défaut

Lors de l'appel de la fonction, si la valeur du paramètre par défaut n'est pas introduite, elle est considérée comme la valeur par défaut. L'exemple suivant affichera l'âge par défaut si l'âge n'est pas indiqué : nom
                                                                            print "Age ",                                                               =9,name="miki" )
                                                                                                                                                                                                                            Le résultat de sortie de l'exemple ci-dessus :

                                                                                                                                                                                                            

                                                                                         Fichier "", ligne 1 Syn taxerror : l'argument autre que celui par défaut suit l'argument par défaut

2. Paramètres performants

Parfois, une fonction peut être requise pour traiter plus de paramètres que lors de l'instruction d'origine. Ces paramètres sont appelés paramètres de longueur variable et ne sont pas nommés lorsqu'ils sont déclarés.

La syntaxe de base est la suivante :

def functionname([formal_args,] *args, **kwargs):
"Function_docstring"
                                                                                                                                                                                                                                                                                                 Expression ]

Les variables avec le numéro étoile (*) ARGS stockeront tous les paramètres de variable sans nom, ARGS est le méta-groupe et la variable KWARGS ajoutera des paramètres clé=valeur, kwargs est un dictionnaire ;

                                                                                                   > imprimer "a =", a
... ... imprimez "b =", b
... ... imprimez "args =", args
. .. print "kwargs: "
             … pour la clé, valeur dans kwargs.items():
                                                                                                                                                                                                                 5, m=6, n=7, p=8) # Notez que les paramètres passés correspondent à des kwargs :
p = 8
m = 6
n = 7
>>>
                                                                                             ;> c = (3, 4, 5)
                                                                                 >>> fun(1, 2, *c, **d) # Faites attention à la méthode de transmission des paramètres des tuples et des dictionnaires
, 5)
kwargs :
p = 8
m = 6
n = 7
                                                                                            ;>
                                                                                      args = ( (3, 4, 5), {'p' : 8, ': 6, 'n': 7})
                                                                               > ; et les types de variables incapables sont utilisés comme paramètres fonctionnels, sera-ce différent ?
Python a-t-il un passage de paramètres de pointeur similaire à celui du langage C ?

                                                                                                                                                  ...
                                                                                                              t;> selfAdd(a_int)
                                                                             1
                                                                                                                                                                                                                                                       >               > Pour les types immuables, la variable dépendante ne peut pas être modifiée, donc l'opération n'affectera pas la variable elle-même
; et pour les types de variables, l'opération dans le corps de la fonction peut modifier la variable paramètre entrante.


Appels de fonctions imbriqués

def testB():
print('---- testB start----')
print('Voici le code exécuté par la fonction testB')
                                                                                                                             testB --- testA start----')

testB()

print('---- testA end----')

testA()

Résultat :

--- - testA start----
---- testB start----
                                                                                                                      ''' coming out'       ' ' ' ' ensemble à travers ' jusqu'à ‐ ‐ ‐‐‐‐ ensemble ensemble pour partir à ​ pour testerUne fin ----



Réflexion et mise en œuvre 1

Écrire une fonction pour imprimer une ligne horizontale
Imprimer un nombre personnalisé de lignes horizontales

Code de référence 1


# Imprimer une ligne de ligne horizontale
DEF PRINTNUMLINE (NUM):
I = 0

# Parce que le La fonction PrintoneERINE a terminé la fonction d'impression horizontale,
# Appelez simplement cette fonction plusieurs fois pour
while i                                                                                                                                                                                                ​​​Écrivez une fonction pour trouver trois nombres La somme de trois nombres
Écrivez une fonction pour trouver la moyenne de trois nombres

Code de référence 2


# Trouvez la somme de trois nombres
def sum3Number(a,b, c):
             return a+b+c # return值
        def moyenne3Nombre(a,b, c):

                                                                                                                                                                                                                     car la fonction sum3Number a déjà complété la somme de 3 nombres, donc juste appelez-le 🎜>          sumResult = sum3Number(a,b,c)
              aveResult = sumResult/3.0
               return aveResult

                       
résultat = moyenne3Nombre (11,2,55)
                                                                                                                                                                                                                        , vous pouvez définir des variables locales portant le même nom, mais l'utilisation de chacune d'entre elles n'affectera pas le rôle des variables locales
Afin de sauvegarder temporairement données, vous devez définir des variables dans la fonction pour le stockage. C'est son rôle

Variable globale
Si une variable peut être utilisée dans une fonction ou dans d'autres fonctions, une telle variable est une variable globale
. 🎜>
La démo est la suivante :

# Define global variables
a = 100

def test1():
print(a)

def test2():
print(a)

           # Fonction d'appel
              test1()
             test2()

                                                                                                                                                                                                    Si vous modifiez une variable globale dans une fonction, vous devez utiliser global pour le déclarer, sinon une erreur se produira
Si le nom de la variable globale est le même que le nom de la variable locale, alors la variable locale est utilisée. Une petite astuce pour créer le puissant dragon. ne pas maîtriser le serpent local<🎜 ​​>

Fonction récursive
Si une fonction n’appelle pas d’autres fonctions en interne, mais elle-même, cette fonction est une fonction récursive.
Par exemple, calculons la factorielle n! = 1 * 2 * 3 * ... * n
def calNum(num):
i = 1
return = 1

while i<=num:
return *= i
i+=1

return result

ret = calNum(3)
print(ret)


Fonction anonyme

Utilisez le mot-clé lambda pour créer une petite fonction anonyme. Ce type de fonction tire son nom du fait que l'étape standard de déclaration d'une fonction avec def est omise.

La syntaxe de la fonction lambda ne contient qu'une seule instruction, comme suit :

lambda [arg1 [,arg2,...argn]]:expression

L'exemple suivant :

sum = lambda arg1, arg2 : arg1 + arg2

#Appeler la fonction somme
print "Valeur du total : ", sum(10, 20)
print "Valeur du total : ", sum( 20, 20 )

Le résultat de sortie de l'exemple ci-dessus :

Valeur du total : 30
Valeur du total : 40

La fonction Lambda peut recevoir n'importe quel nombre de paramètres mais ne peut renvoyer que la valeur d'une expression

Les fonctions anonymes ne peuvent pas appeler print directement car lambda nécessite une expression
Occasions d'application
Les fonctions sont passées en paramètres

Fonction d'auto-définition

                                                                                                             , ,                                          > > a = 1
b = 2
résultat = 3

En tant que paramètre de la fonction intégrée

Pensez-y, comment précisez-vous les données suivantes à trier par âge ou par nom ?

stus = [
{"name": "zhangsan", "age": 18},
{"name": "lisi", "age": 19},
{"name": "wangwu", "age": 17}
]

Trier par nom :

>>> x['nom'])
>>> stus
[{'âge' : 19, 'nom' : 'lisi'}, {'âge' : 17, 'nom' : 'wangwu '}, {'age' : 18, 'name' : 'zhangsan'}]

Trier par âge :

>>> x['age'])
>>> stus
[{'age' : 17, 'nom' : 'wangwu'}, {'age' : 18, 'nom' : 'zhangsan '}, {'age' : 19, 'name' : 'lisi'}]

Remarques sur l'utilisation des fonctions

1. Fonction personnalisée

<1> paramètres, aucune valeur de retour

                                                                                                                                                                                                                :
         .                                                                                                                                                                                            🎜>En développement, les fonctions sont souvent conçues en fonction des besoins si elles doivent renvoyer une valeur
Dans une fonction, il peut y avoir plusieurs instructions return, mais tant qu'une instruction return est exécutée, cela signifie que l'appel de cette fonction est terminé

& lt; 3 & gt; il y a des paramètres, pas de valeur de retour

Nom de la fonction DEF (liste formelle des paramètres) :
phrase

Remarque :

lors de l'appel de la fonction, si nécessaire, si vous en avez besoin, vous devez transmettre des données ensemble, et la fonction appelée doit utiliser des paramètres pour les recevoir
Le nombre de variables dans la liste des paramètres est déterminé en fonction de la quantité de données réellement transmises

Valeur

nom de la fonction def (liste des paramètres):

2. Fonction d'appel

                                                                                                                                                                                                                                                              

Si la fonction appelée a des paramètres formels lorsqu'elle est définie, alors les paramètres doivent être transmis lors de l'appel

Conformément aux exigences
                                                                                                                                     ;1> )

         <2> Les variables définies en dehors de la fonction peuvent être utilisées dans toutes les fonctions (variables globales)
Recommandations associées :


Introduction aux fonctions de base de Python

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!