Points de base en python

Aperçu de base des fonctions

Avant d'apprendre les fonctions, vous avez toujours suivi : la programmation orientée processus, c'est-à-dire : l'implémentation de fonctions de haut en bas basées sur la logique métier. Vous pouvez réfléchir s'il existe plusieurs codes. pour une certaine fonction. Est-il possible de l'écrire une seule fois s'il est utilisé à chaque endroit ? Comment le code devrait-il être défini à ce stade? Observez d'abord le cas suivant :

while True :
si utilisation du processeur> 90 % :
#Envoyer un rappel par e-mail
Se connecter au serveur de boîte aux lettres
Envoyer un e-mail
Fermer le connexion
                                                                                                                                                                                                    Utilisation de la mémoire> 80 % :
       #Envoyer un rappel par e-mail
                                                                                                                                                                                                                                                                      >
def Envoyer un e-mail (contenu)
#Envoyer un rappel par e-mail
Se connecter au serveur de messagerie
Envoyer un e-mail
Fermer la connexion

pendant que Vrai :

si taux d'utilisation du processeur > 90 % :

Envoyer un e-mail (« Alarme CPU »)

si espace d'utilisation du disque dur > 90 % :

Envoyer un e-mail (« Alarme du disque dur »)

si utilisation de la mémoire> 80 % :
Envoyer un e-mail (« Alarme de mémoire »)

Pour ce qui précède deux méthodes d'implémentation, la deuxième fois doit être meilleure que la première fois en termes de réutilisabilité et de lisibilité. Cela peut réduire beaucoup de temps de code et de développement. Il peut être défini en un seul endroit et appelé à plusieurs endroits. programmation fonctionnelle

Le concept de programmation fonctionnelle :
Lors du développement d'un programme, un certain morceau de code est nécessaire plusieurs fois. Utiliser, mais afin d'améliorer l'efficacité de l'écriture et la réutilisation du code, des blocs de code avec des fonctions indépendantes sont organisé en un petit module. C'est la définition et l'appel de la fonction

fonction

<1>Définir la fonction

Le format de définition de la fonction est le suivant :

def function name():

Code

　demo:

　# Définir une fonction qui peut compléter la fonction d'impression des informations

　 def printInfo():　　print '---------------- ---------------- ----------'　　　print 'La vie est courte, j'utilise Python'　　　print '---------- ----------- -------------'



La définition de la fonction comporte principalement les points suivants :

　
• def : mot-clé représentant une fonction • Nom de la fonction : le nom de la fonction, la fonction est appelée selon le nom de la fonction lors de l'appel


• Corps de la fonction : effectué dans la fonction Une série de logiques calculs ou le contenu fonctionnel de la fonction.

　• Paramètres : fournir des données pour le corps de la fonction

　• Valeur de retour : lorsque la fonction est exécutée, les données peuvent être renvoyées à l'appelant.

<2> Appeler une fonction
Après avoir défini une fonction, cela équivaut à avoir un code avec certaines fonctions Pour réaliser celles-ci. codes exécutables, vous devez l'appeler (notez que le contenu à l'intérieur ne sera pas exécuté lors de la définition de la fonction)
L'appel de la fonction est très simple, et l'appel peut être complété via le nom de la fonction () demo :
　# Après avoir défini la fonction, la fonction ne sera pas exécutée automatiquement, vous devez l'appeler 　printInfo()

< 3> description du document de fonction

Exemple :

>>> def test(a,b):

... "Utilisé pour compléter la somme de 2 nombres"

... print("%d"%(a+b))

...
>>>

>>> >33

Exécuter, le code suivant
>>> help(test)Vous pouvez voir les instructions pertinentes de la fonction de test===== ===== =====================================

Aide sur la fonction test dans le module __main__ :

test(a, b)
permet de compléter la somme de 2 nombres
(FIN)

==============================================

Paramètres de fonction-valeur de retour

<1> une fonction avec des paramètres
L'exemple est le suivant :
def addnum(a, b):
c = a+b
　print c
<2> Appeler une fonction avec des paramètres
Pour appeler la fonction add2num(a, b) ci-dessus : Exemple :

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

　add2num(11, 22) #Lors de l'appel d'une fonction avec des paramètres, vous devez passer les données entre parenthèses

Résumé :
• Le les paramètres entre parenthèses lors de la définition sont utilisés pour recevoir des paramètres, et sont appelés "paramètres formels"
• Les paramètres entre parenthèses lors de l'appel sont utilisés pour passer à la fonction, sont appelés "paramètres réels"

　ps : Il y aura un blog séparé expliquant les paramètres des fonctions en détail plus tard

<3>
Exemple :
def add2num(a, b):
Return c
Un exemple de la valeur de retour de la fonction enregistrée est la suivante :
#Define function

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

#Appelez la fonction et enregistrez la valeur de retour de la fonction

result = add2num(100,98)
　

#Parce que le résultat a enregistré la valeur de retour de add2num, il peut être utilisé ensuite imprimer le résultat
Résultat :
198

En python nous pouvons renvoyer plusieurs valeurs
(a, b) :... shang = a//b
... yushu = a%b
... retourner shang, yushu
...
> sh, yu = divid(5, 2)
　> ;>> sh
　5
　>>> yu
　1

L'essence est d'utiliser des tuples

Les fonctions peuvent être combinées entre elles selon qu'il y a des paramètres et s'il y a une valeur de retour. Il y a 4 types au total

　• Pas de paramètres, pas de valeur de retour
　• Pas de paramètres, pas de valeur de retour　• Il y a des paramètres, pas de valeur de retour
　• Il y a des paramètres, il y a une valeur de retour


　<1>Fonction sans paramètres, pas de valeur de retour

Ce type de fonction ne peut pas accepte les paramètres et n'a pas de valeur de retour. Généralement, pour les fonctions similaires à l'impression de voyants d'invite, utilisez ce type de fonction

Les fonctions de classe ne peuvent pas recevoir de paramètres, mais peuvent renvoyer certaines données. Généralement, ces fonctions sont utilisées pour collecter des données
. <3> Fonctions avec paramètres et aucune valeur de retour
Paramètres, mais ne peuvent pas renvoyer de données De manière générale, lors de la définition de données pour certaines variables sans exiger de résultats, utilisez ce type de fonction
　<4> paramètres et valeur de retour
　Ce type de fonction, Elle peut non seulement recevoir des paramètres, mais aussi renvoyer certaines données. Généralement, pour les applications qui traitent des données et nécessitent des résultats, utilisez ce type de fonction

Petit résumé<.>


           Les fonctions peuvent être combinées entre elles selon qu'elles ont ou non des paramètres et des valeurs de retour• Lors de la définition d'une fonction, elle est conçue en fonction des exigences fonctionnelles réelles, donc les types de fonctions écrits par différents développeurs sont différents• Qu'est-ce qu'une fonction exactement ? S'il n'y a pas de valeur de retour, cela dépend s'il y a un retour, car seul le retour peut renvoyer des données

• En développement, les fonctions sont souvent conçues selon les besoins, ils doivent renvoyer une valeur

• Il peut y avoir plusieurs instructions return dans une fonction, mais tant qu'une instruction return est exécutée, cela signifie que l'appel de cette fonction est terminé
•
Essayez de ne pas répéter les noms des fonctions dans un programme. Lorsque les noms de fonctions sont répétés, les derniers écraseront les précédents (remarque : ne répétez pas également le nom de la variable et il sera écrasé)



Imbrication de fonctions

def testB():
print('---- testB start----')
print('Ceci est testB Le code exécuté par la fonction...(omis)...')
　print('---- testB end----')

def testA():

print('---- testA start----')

testB()

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

Appeler

testA()

Résultat :
---- testA start----
---- testB start--- -
Voici le code exécuté par la fonction testB...(omis)...
---- fin testB----
---- fin testA----

Petit résumé:
　 • Une fonction appelle une autre fonction, C'est ce qu'on appelle appel de fonction imbriquée
　 • Si une autre fonction B est appelée dans la fonction A, alors toutes les tâches de la fonction B seront exécutées en premier avant de revenir à la fonction précédente. position où la fonction secondaire A est exécutée

Cas d'imbrication de fonctions :

　1. Écrivez une fonction pour trouver la somme de trois nombres
　2. Écrivez une fonction pour trouver la moyenne de trois nombres


　# Trouvez la somme de trois nombres
def sum3Number(a,b , c):
return a+b+c # return peut être suivi d'une valeur numérique ou d'une expression

　# Complétez la moyenne de 3 nombres
　def moyenne3Nombre(a,b,c):

　# Parce que la fonction sum3Number a déjà complété la somme de trois nombres, il suffit de l'appeler
　 # Autrement dit, les trois nombres reçus peuvent être transmis comme paramètres réels
　sumResult = sum3Number(a,b,c)
　 aveResult = sumResult/3.0
return aveResult

　# Appelez la fonction pour compléter la moyenne de 3 nombres

　result = Average3Number(11,2,55)

　print("average is %d"%result)

Variables locales et variables globales de la fonction

Variables locales

Exemple :
Dans [8] : def text1():
...: a = 200

. ..: Imprimer ("Texte1 ----- %D" %A)
...: Imprimer ("Après modification")
...: A = 300
..: imprimer. ("text1----%d" %a)
...:

Dans [9]: def text2():

a = 400                                                                                                                                                                                                    print("text2- ----%d" %a) 🎜>　text1----200
　Modifié
　text1----300

　Dans [11] : text2()

　text2- ----400

Résumé

　　• Les variables locales sont des variables définies à l'intérieur d'une fonction

　　• Différentes fonctions peuvent définir des variables locales avec le même nom, mais l'utilisation de chacune d'elles le fera n'a pas d'impact

　• Le rôle des variables locales, afin de sauvegarder temporairement les données, il faut définir des variables dans la fonction de stockage, c'est son rôle

Variables globales

Concept : Si une variable peut être utilisée dans une fonction ou dans d'autres fonctions, une telle variable est une variable globale

　 Exemple :

text1():

...: print("----text1----% d" %a) ...: Dans [14]: def text2( ):                                                                                                                                                                                                                                                                                             )

　----text1----250

.

　Dans [16] : text2()
　----text2----250

　

　Lorsque les variables locales et les variables globales ont le même nom Quand :
Dans [23] : a = 250 # Variable globale

Dans [24] : def text1():
. .: 　 　 　　 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 　　..: 　 　　 # Variable locale

　　 　　 ...: 　　 　　 　　...:
　　Dans [25] : def text2(): 　　　.. .:　　　 print("----text2----%d" %a)
　　 .. .:

　Dans [26] : text1()

　----text1- ---521

　　----text1----666

　Dans [ 27] : text2()

　　　----text2----250

Dans [28] :

　

　 Résumé :

　　• Les variables définies en dehors d'une fonction sont appelées variables globales

　　• Les variables globales sont accessibles dans toutes les fonctions 　　• Si le nom de la variable globale est le même que le nom de la variable locale, alors les variables locales sont utilisées, une petite astuce pour tenir les serpents locaux à distance

Modifier les variables globales à l'intérieur de la fonction :

Dans [31] : a = 250

Dans [32] : def text1(): . ..: a = 520 ...: print("----text1----%d" %a )
Dans [33] :

Dans [ 33]: def text2():
...:
global
a
...: a = 666
　...: Print("----text2-- --%d" %a)
　... :
Dans [34] : # Aucune fonction n'est appelée


Dans [35] : print( a)
250
Dans [36] : # Appel text1


Dans [37] : text1()
----text1-- --520
Dans [38] : # Imprimer à nouveau---->


　　Dans [39] : print(a)
　　250
　　Dans [40] : # Trouvé que la valeur n'a pas été modifiée


　　Dans [41] :
# Appeler text2
Dans [42] : text2()
　　----text2----666
　　Dans [43] : # Imprimer à nouveau un


Dans [ 44] : print(a)
666
Dans [45] : # La valeur a été modifiée

　　
Résumé :

　　　• Si vous modifiez une variable globale dans une fonction, vous devez utiliser global pour la déclarer, sinon cela équivaut à la redéfinir à l'intérieur de la fonction (sans passer de paramètres) Un objet de la même variable
　
La différence entre - les variables globales de type variable - et les variables globales de type immuable - modifiées à l'intérieur de la fonction

　ps : Il y aura sera un blog plus tard qui expliquera en détail les concepts de types variables et de types immuables

Exemple : -------> ;Type immuable :

Dans [46] : a = 6 Dans [47] : def demo(): ...: a += 1 ...: print(a)
...:

Dans [48] : demo()

Message d'erreur :
------------- --------------- ----------------------------------- ------------
UnboundLocalError         Traceback (dernier appel le plus récent)

　　　 mo()

　　　 dans demo()

　　　　　 　　1 def demo():
　　　　——> 　　 　　 a += 1
3

　　　UnboundLocalError : variable locale 'a' référencée avant l'affectation

　　　------------------------------- - -----------------------------------------------
　Remarque : Evidemment elle ne peut pas être modifiée

------->Type de variable :

Dans [49] : a = [1,]

Dans [50] :

Dans [50] : def demo():
...: a.append(2)
print(a)
. .:

Dans [51] : demo()
[1, 2]

Dans [52] : a
Sortie[52] : [1, 2]

Lorsqu'une fonction est appelée, la valeur de la liste est modifiée à l'intérieur de la fonction lorsque la fonction est exécutée - et également modifiée lorsqu'elle est imprimée en externe.
Résumé :

○ Si vous modifiez une variable globale dans une fonction, vous devez utiliser global pour la déclaration, sinon une erreur se produira
○ Ne pas utiliser de déclaration globale dans la fonction L'essence des variables globales ne peut pas être modifiée est que ne peut pas modifier le point des variables globales , signifie que ne peut pas pointer les variables globales vers de nouvelles données .
　　○ Pour les variables globales de type immuable , les données pointées par ne peuvent pas être modifiées , donc si global n'est pas utilisé, ne peut pas modifier la variable globale .
○ Pour les variables globales de type de variable , les données pointées par peuvent être modifiées , donc lorsque global n'est pas utilisé, peut également modifier le global variable.

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!