Page d'accueil de l'auteur : Boussole de programmation
À propos de l'auteur : Créateur de haute qualité dans le domaine Java, expert du blog CSDN
, partenaire de contenu CSDN, auteur invité de Nuggets, expert du blog Alibaba Cloud, auteur invité 51CTO, de nombreuses années d'expérience en conception d'architecte, conférencier résident de la classe TencentContenu principal : projet Java, projet Python, projet front-end, intelligence artificielle et big data, modèle de CV, supports d'apprentissage, banque de questions d'entretien, entraide technique
Favoris, likes, ne vous perdez pas, ça fait du bien de suivre l'auteur
Obtenez le code source à la fin de l'article
3. La fonction réalise une programmation modulaire
Dans les langages de programmation, les fonctions sont principalement utilisées pour encapsuler les codes associés, réaliser une programmation modulaire et compléter les paramètres réutilisables du code. Python possède des fonctions intégrées et des fonctions personnalisées.
3.1 Définition et appel de la fonction
grammaire:
def functionname([parameterlist]):
['''comments''']
[functionbody]
* functionname: 函数名
* parameterlist: 参数列表
* comments: 说明
* functionbody : 函数体
Exemple : Définir une fonction filterchar() qui filtre les caractères dangereux
def filterchar(string):
'''功能说明：过滤指定的字符串，并将过滤后的结果输出
没有返回值
'''
import re #导入Python的re模块
pattern = r'(黑客)|(抓包)|(监听)|(Trojan)' #模式字符串
sub = re.sub(pattern,'@_@',string) #进行模式替换
print(sub)
Syntaxe de base pour appeler des fonctions.
functionname([parametersvalue])
Exemple:
str = '我是一名热爱黑客的程序员，喜欢研究Trojan'
filterchar(str)
Si vous ne savez pas quoi faire après avoir défini une fonction, vous pouvez utiliser pass pour remplir le corps de la fonction, ou utiliser '...' pour indiquer une omission de code.
def functionname():
pass
def functionname():
...
3.2 Passage de paramètres
Le rôle des paramètres est de transmettre des données à la fonction pour utilisation et d'effectuer le traitement des données correspondant dans le corps de la fonction.
Paramètres formels : Abrégés en paramètres formels, ils font référence aux paramètres entre parenthèses lors de la définition d'une fonction. Comme un personnage dans un scénario de film.
Paramètre réel : abrégé en paramètre réel, il fait référence à la valeur réelle du paramètre transmise lors de l'appel de la fonction. Comme un acteur jouant un rôle au cinéma.
Selon les différents types de paramètres réels, il est divisé en transfert de valeur (le type est un type immuable) et transfert de référence (le type est un type variable). La différence spécifique entre les deux est que lors du passage par valeur, la valeur du paramètre formel est modifiée, mais la valeur du paramètre réel reste inchangée ; lors du passage par référence, la valeur du paramètre formel est modifiée et la valeur de le paramètre réel change également.
Exemple:
#值传递和引用传递
def demo(obj):
print("原值:",obj)
obj += obj
#调用函数
print("---------值传递--------")
mot = "唯有在被追赶的时候，你才能真正的奔跑"
print("函数调用前：",mot)
demo(mot)
print("函数调用后：",mot)
print("---------引用传递--------")
list1 = ['邓肯','吉诺比利','帕克']
print("函数调用前：",list1)
demo(list1)
print("函数调用后：",list1)
Lors de la transmission des paramètres, les exigences en matière de quantité et de type de données sont cohérentes avec les exigences en matière de paramètres lors de la définition des fonctions. Il peut également être transmis via des paramètres de mots clés, afin que vous n'ayez pas à maintenir la position du paramètre cohérente avec la définition.
Par exemple:
functionname(height=20,width=30,height=50)
Valeur par défaut du paramètre : vous pouvez également spécifier une valeur par défaut pour le paramètre, afin de pouvoir appeler sans transmettre le paramètre.
#函数参数默认值
def abc(str='aaa'):
print(str)
abc()
Paramètres variables : l'un est *paramètre, l'autre est **paramètre
*paramètre : indique qu'un nombre quelconque de paramètres réels sont acceptés dans un tuple.
Exemple:
#定义可变参数
def printplayer(*name): #定义输出我喜欢的NBA球员函数
print('\n 我喜欢的NBA球员有:')
for item in name:
print(item) #输出球员名称
printplayer('邓肯')
printplayer('邓肯','乔丹','大佛')
Si vous souhaitez utiliser une liste existante comme paramètre, vous pouvez ajouter * avant le nom de la liste
param =['邓肯','乔丹','大佛']
printplayer(*param)
**paramètre : indique que plusieurs paramètres pouvant se voir attribuer un nombre quelconque de valeurs d'affichage sont acceptés et placés dans un dictionnaire.
#可变参数
def printsign(**sign):
print()
for key,value in sign.items():
print("["+key+"] 的绰号是:"+value)
printsign(邓肯='石佛',罗宾逊='海军上将')
Si vous souhaitez passer un dictionnaire existant en paramètre de variable, vous pouvez ajouter ** avant le nom du paramètre :
param ={'邓肯':'石佛','罗宾逊':'海军上将'}
printsign(**param)
3.3 valeur de retour
Une fois la fonction exécutée, le résultat d'exécution correspondant peut être renvoyé.
Exemple:
#函数返回值
def fun_checkout(name):
nickname=""
if name == '邓肯':
nickname = '石佛'
elif name == '吉诺比利':
nickname = '妖刀'
elif name == '罗宾随逊':
nickname = '海军上将'
else:
nickname = '查无此人'
return nickname
while FutureWarning:
name = input("请输入NBA求员的名称:")
nickname = fun_checkout(name)
print("球 员:",name,"绰号:",nickname)
3.4 Portée des variables
Variable locale : fait référence à la variable définie à l'intérieur de la fonction, qui ne peut être utilisée qu'à l'intérieur de la fonction.
Variable globale : si une variable est définie en dehors de la fonction, elle peut être utilisée en dehors de la fonction ou à l'intérieur de la fonction ; ajoutez le mot-clé global avant le nom de la variable défini dans le corps de la fonction, et cette variable peut également devenir une variable globale.
Exemple:
#局部变量
def fun_variable():
var_name = '指南针毕业设计出品'
print(var_name)
fun_variable()
print(var_name) #函数名使用局部变量时，抛出 NameError
Exemple:
#全局变量
var_name = '指南针毕业设计出品'
def fun_variable():
print(var_name)
fun_variable()
print(var_name)
Exemple:
#全局变量
def fun_variable():
global var_name
var_name = '指南针毕业设计出品'
print(var_name)
fun_variable()
print(var_name)
3.5 Fonctions anonymes
Si vous ne spécifiez pas de nom pour la fonction, il s'agit généralement d'un appel ponctuel, temporaire.
result = lambda[args[,args,..argn]]:expression
* result:用于调用lambda表达式
* [arg1[,arg2,...argn]]:可选参数，用于指定要传的参数列表，多个参数间用,号分隔
* expression:必须参数，用于指定一个实现具体功能的表达式.
Exemple : Calculer le rayon d'un cercle
import math
def circlearea(r):
result = math.pi*r*r
return result
r = 10
print("半径为",r,"的圆的面积为:",circlearea(r))
Si vous utilisez une fonction anonyme pour obtenir les résultats suivants :
import math
r = 10
result = lambda r:math.pi*r*r
print("半径为",r,"的圆的面积为:",result(r))
3.6 Fonctions intégrées couramment utilisées par Python
