Introduction aux bases des fonctions Python

Cet article présentera comment organiser les instructions en fonctions, ainsi que le concept de paramètres et leur utilisation dans les programmes. Les amis dans le besoin peuvent s'y référer

Les fonctions Python sont écrites par une nouvelle instruction, à savoir. def , def est une instruction exécutable - la fonction n'existe pas tant que Python n'exécute pas def.

La fonction est passée par affectation et les paramètres sont passés à la fonction par affectation

L'instruction def créera un objet fonction et l'attribuera à un nom de variable. Le format général de l'instruction def. est le suivant :

Copier le code Le code est le suivant :

def function_name(arg1,arg2[,...]) :
instruction
[valeur de retour]

La valeur de retour n'est pas nécessaire. S'il n'y a pas d'instruction de retour, Python renvoie la valeur None par défaut.

Règles de dénomination des noms de fonctions :

Les noms de fonctions doivent commencer par un trait de soulignement ou une lettre et peuvent contenir n'importe quelle combinaison de lettres, de chiffres ou de traits de soulignement. Aucun signe de ponctuation ne peut être utilisé ; les noms de fonctions

sont sensibles à la casse.

Les noms de fonctions ne peuvent pas être des mots réservés.

Python utilise le concept d'espace de noms pour stocker des objets. Cet espace de noms est la zone dans laquelle l'objet agit. Différents objets existent dans différentes portées. Voici les règles de portée pour les différents objets :

Chaque module a sa propre portée globale.

L'objet défini par la fonction appartient à la portée locale et n'est valide qu'au sein de la fonction et n'affectera pas les objets de la portée globale.

L'objet attribué est dans la portée locale sauf s'il est déclaré à l'aide du mot-clé global.

Les règles LGB sont les règles permettant à Python de trouver des noms. Voici les règles LGB :

1. La plupart des références de noms sont recherchées dans trois portées : premièrement locale (Local), deuxièmement globale (. Global), encore une fois intégré (Build-in).

Copier le code Le code est le suivant :

>>> a=2
>>>
>>> def test(b):
... test=a*b
... return test
>>>print test(10)
20

b se trouve dans la portée locale, et a se trouve dans la portée globale.

2. Si vous souhaitez changer l'objet de la portée globale dans la portée locale, vous devez utiliser le mot-clé global.

Copier le code Le code est le suivant :

#La situation où global n'est pas utilisé
>>> "
>>> def set():
... name="ringkee"
...
>>> set()
>> ;> print name
Jims

#La situation après l'utilisation de global
>>> name="Jims"
>>> 🎜>..     nom global
...     name="ringkee"
...
>>> set1()
>>> ringkee


3. La déclaration 'globale' mappe le nom attribué à la portée d'un module qui le contient.

Les paramètres d'une fonction sont le pont entre la fonction et le monde extérieur. Ils peuvent recevoir des valeurs transmises de l'extérieur. Les règles de transmission des paramètres sont les suivantes :

4. L'attribution d'un nom de paramètre dans une fonction n'affecte pas l'appelant.

Copier le code

Le code est le suivant :

>>> a=1

>>> a):
... a=a+1
... imprimer a
...
>>> test(a)
2
> >> ; a
1                                                                                                                                                                                                        # une valeur reste inchangée


5. La modification d'un paramètre d'objet variable dans une fonction affectera l'appelant.

Copier le code

Le code est le suivant :

>>> a=1

>>> 1,2 ]
>>> def test(a,b):
... a=5
... b[0]=4
... imprimer un ,b
...
>>> test(a,b)
5 [4, 2]
>>> ;> > b
[4, 2] # La valeur b a été modifiée


Le paramètre est un pointeur d'objet, et il n'est pas nécessaire de définir le type d'objet transmis. Par exemple :

Copier le code

Le code est le suivant :

>>> .. return a +b...

>>> test(1,2) #Type numérique

3
>>> b") # Type de caractère
'ab'
>>> test([12],[11]) #Liste
[12, 11]


Paramètres dans la fonction Recevoir la valeur transmise. Les paramètres peuvent être divisés en paramètres par défaut, tels que :

def function(ARG=VALUE)
Paramètres des tuples :

def function(*ARG)
Paramètres du dictionnaire :

def function(**ARG)
Quelques règles de fonction :

La valeur par défaut doit être autre que celle par défaut Après les paramètres ;

Dans une seule définition de fonction, un seul paramètre de tuple (*ARG) et un seul paramètre de dictionnaire (**ARG) peuvent être utilisés.

Le paramètre tuple doit venir après les paramètres de connexion et les paramètres par défaut.

Les paramètres du dictionnaire doivent être définis en dernier.

1. Fonctions couramment utilisées
1.abs(x)

abs() renvoie la valeur absolue d'un nombre. Si un nombre complexe est donné, la valeur de retour est le module du nombre complexe.

Copier le code Le code est le suivant :

>>>print abs(-100)
100
> >> ;print abs(1+2j)
2.2360679775

2.callable(object)

La fonction callable() est utilisée pour tester si l'objet est appelable , et renvoie 1 si c'est possible (True) ; sinon, renvoie 0 (False). Les objets appelables incluent des fonctions, des méthodes, des objets de code, des classes et des instances de classe qui ont défini des méthodes « d'appel ».

Copier le code Le code est le suivant :

>>> a="123"
>>> callable(a )
0
>>> print callable(chr)
1

3.cmp(x,y)

cmp () Compare deux objets x et y et renvoie un entier basé sur le résultat de la comparaison. Si xy, il renvoie 1, et si x==y, il renvoie 0.

Copier le code Le code est le suivant :

>>>a=1
>>>b=2
>>>c=2
>>> imprimer cmp(a,b)
-1
>>> 🎜>1
>>> imprimer cmp(b,c)
0

4.pmod(x,y)

pmod(x, y) fonction Termine l'opération de division et renvoie le quotient et le reste.

Copier le code Le code est le suivant :

>>> 🎜>> ;>> pmod(9,3)
(3, 0)


5.isinstance(objet,classe-ou-type-ou-tuple) -> bool

Type d'objet de test

Copier le code

Le code est le suivant :

>>> '

> >> b=1234

>>> estinstance(a,str)
Vrai
>>> Faux
> >> isinstance(b,str)
Faux
>>> isinstance(b,int)
Vrai


Ce qui suit le programme affiche la fonction isinstance Utiliser :

Copier le code

Le code est le suivant :

def displayNumType(num): print num, 'is ',

if isinstance( num, (int, long, float, complex)):

print 'un certain nombre de type:', type(num).__name__
else:
print 'not un numéro du tout !!!'


Le résultat de l'exécution du code est le suivant :


Copier le code
Le code est le suivant :


-69 est un nombre de type : int

99999999999999999999999999999 est un nombre de type : long

565.8 est un nombre de type : float

(-344.3+34.4j) est un nombre de type : complexe

xxx n'est pas un nombre du tout !!!

6.len(object) -> integer

la fonction len() renvoie la longueur de la chaîne et de la séquence.


Copier le code
Le code est le suivant :

>>> len("aa")

2

> >> ; len([1,2])

2

7.pow(x,y[,z])

la fonction pow() renvoie x comme base, y est la puissance de l'exposant. Si une valeur z est donnée, la fonction calcule la valeur de x élevée à la puissance y modulo z.


Copier le code
Le code est le suivant :

>>> print pow(2,4)

16

> ;> > imprimer pow(2,4,2)

0

>>> imprimer pow(2.4,3)13.824

8.range La fonction ([lower,]stop[,step])

range() peut générer une liste continue ordonnée d'entiers en fonction de paramètres.


Copier le code
Le code est le suivant :

>>> , 4, 5, 6, 7, 8, 9]

>>> plage(1,10)

[1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> plage(1,10,2)

[1, 3, 5, 7, 9]

9.round(x[,n])

La fonction round() renvoie la valeur arrondie du nombre à virgule flottante x. Si la valeur n est donnée, elle représente le nombre de chiffres après la virgule décimale.

Copier le code Le code est le suivant :

>>> rond(3.333)
3.0
>> > rond (3)
3.0
>>> rond(5.9)
6.0

10.type(obj)

type( ) la fonction peut Renvoie le type de données de l'objet.

Copier le code Le code est le suivant :

>>> type(a)

>>> type(copie)

>>> type(1)

11.xrange([lower,]stop[,step])

La fonction xrange() est similaire à range(), mais xrnage() ne crée pas de liste, mais renvoie un objet xrange. Il se comporte comme une liste, mais ne calcule les valeurs de la liste qu'en cas de besoin. Cette fonctionnalité peut nous faire économiser de la mémoire lorsque la liste est grande.

Copier le code Le code est le suivant :

>>> a=xrange(10)
>>> imprimer un[ 0]
0
>>> imprimer un[1]
1
>>> imprimer un[2]
2

2. Fonction de conversion de type intégrée
1.chr(i)

La fonction chr() renvoie la chaîne correspondant au code ASCII.

Copier le code Le code est le suivant :

>>> print chr(65)
A
>> ;> imprimer chr(66)
B
>>> imprimer chr(65)+chr(66)
AB

2.complexe(réel[ ,imaginaire] )

La fonction complex() peut convertir une chaîne ou un nombre en un nombre complexe.

Copier le code Le code est le suivant :

>>> complexe("2+1j")
(2+1j )
>>> complexe("2")
(2+0j)
>>> complexe(2,1)
(2+1j)
>> ;> complex(2L,1)
(2+1j)

3.float(x)

la fonction float() convertit un nombre ou une chaîne en nombre à virgule flottante.

Copier le code Le code est le suivant :

>>> float("12")
12.0
> >> ; La fonction hex() convertit les entiers en nombres hexadécimaux.


Copier le code
Le code est le suivant :

>>> hex(16)

'0x10'

> >> ; hex(123)

'0x7b'

5.long(x[,base])

la fonction long() convertit les nombres et les chaînes en entiers longs , base est une base facultative.


Copier le code
Le code est le suivant :

>>> long("123")

123L

> >> ; long(11)

11L

6.list(x)

la fonction list() peut convertir des objets de séquence en listes. Par exemple :


Copier le code
Le code est le suivant :

>>> h', 'e', ​​'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

>>> ; liste(( 1,2,3,4))

[1, 2, 3, 4]

7.int(x[,base])

Fonction int() Convertit les nombres et les chaînes en un entier, base est une base facultative.


Copier le code
Le code est le suivant :

>>> int(3.3)

3

>> >int (3L)

3

>>> int("13")13>>>

La fonction 8.min(x[,y,z...])

min() renvoie la valeur minimale du paramètre donné, qui peut être une séquence.


Copier le code
Le code est le suivant :

>>> min(1,2,3,4)

1

> ;>> min((1,2,3),(2,3,4))

(1, 2, 3)

9.max(x La fonction [,y ,z...])

max() renvoie la valeur maximale du paramètre donné, qui peut être une séquence.

Copier le code
Le code est le suivant :

>>> max(1,2,3,4)

4

> ;>> max((1,2,3),(2,3,4))

(2, 3, 4)

10.oct(x )

La fonction oct() peut convertir l'entier donné en un nombre octal.

Copier le code Le code est le suivant :

>>> oct(8)
'010'
>>> ; oct( 123)
'0173'

11.ord(x)

La fonction ord() renvoie le code ASCII ou la valeur Unicode d'un paramètre de chaîne.

Copier le code Le code est le suivant :

>>> ord("a")
97
> >> ; ord(u"a")
97

12.str(obj)

str() convertit l'objet en une chaîne imprimable.

Copier le code Le code est le suivant :

>>> str("4")
'4'
>> ;> str(4)
'4'
>>> str(3+2j)
'(3+2j)'

La fonction 13.tuple (x)

tuple() convertit les objets séquence en tuples.

Copier le code Le code est le suivant :

>>> 'e' , 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd')
>>> [1, 2,3,4])
(1, 2, 3, 4)

3. Fonctions de traitement de séquence

1. () parmi les fonctions courantes, min() peut également être utilisé avec des séquences.

2.filter(function,list)

Lorsque filter() est appelé, il applique une fonction à chaque élément de la séquence et renvoie toutes les valeurs lorsque la fonction renvoie de vrais éléments , filtrant ainsi tous les éléments qui renvoient une fausse valeur.

Copier le code Le code est le suivant :

>>> def nobad(s):
... Renvoie s. find(" mauvais") == -1
...
>>> s = ["mauvais", "bon", "bade", "nous"]
>> ;> filter(nobad,s)
['good', 'we']

Cet exemple filtre tous les éléments contenant « mauvais » en appliquant la fonction nobad() à tous les éléments. dans la séquence s.

3.map(function,list[,list])

La fonction map() applique une fonction à tous les éléments de la séquence et renvoie une liste.

Copier le code Le code est le suivant :

>>> chaîne d'importation
>>> python", "zope", "linux"]
>>> map(string.capitalize,s)
['Python', 'Zope', 'Linux']

map() peut également être appliqué à plusieurs listes en même temps. Par exemple :

Copier le code Le code est le suivant :

>>> =[1, 2,3]; t=[3,2,1]
>>> map(operator.mul,s,t) # s[i]*t[j]
[3, 4 , 3]


Si vous transmettez une valeur None au lieu d'une fonction, map() combinera les éléments correspondants dans chaque séquence et renverra le tuple. Par exemple :

Copier le code

Le code est le suivant :

>>> ,4]; c=[5,6]

>>> carte(Aucun,a,b,c)
[(1, 3, 5), (2, 4, 6)]


4.reduce(function,seq[,init])

La fonction réduire() obtient les deux premiers éléments de la séquence et les transmet à la fonction fournie après obtention. le résultat, la séquence est obtenue. L'élément suivant est transmis à la fonction avec le résultat, et ainsi de suite jusqu'à ce que tous les éléments aient été traités.

Copier le code

Le code est le suivant :

>>> opérateur d'importation

>>> mul,[ 2,3,4,5]) # ((2*3)*4)*5
120
>>> 5], 1) # (((1*2)*3)*4)*5
120
>>> réduire(operator.mul,[2,3,4,5], 2) # (((2*2)*3)*4)*5
240


5.zip(seq[,seq,...])

zip() combine les éléments correspondants de deux séquences ou plus et les renvoie au format tuple, s'arrêtant après avoir traité tous les éléments dans la séquence la plus courte.

Copier le code

Le code est le suivant :

>>> ,[7 ,8,9])

[(1, 4, 7), (2, 5, 8)]

Si le paramètre est une séquence, zip() sera un tuple Le format renvoie chaque élément, tel que :

Copier le code

Le code est le suivant :

>>> ,2,3,4 ,5))

[(1,), (2,), (3,), (4,), (5,)]

>>> [1,2,3 ,4,5])
[(1,), (2,), (3,), (4,), (5,)]

4.D'autres
def instructions sont exécutées en temps réel.Lors de son exécution, il crée et attribue un nouvel objet fonction à un nom de variable.Toutes les instructions Python sont exécutées en temps réel, contrairement au processus de compilation indépendant. comme ça

Parce qu'il s'agit d'une instruction, def peut apparaître partout où une instruction peut apparaître - même imbriquée dans d'autres instructions :

Copier le code Le code est le suivant :

if test :
def fun():
...
else:
def func():
...
...
func()

Vous pouvez attribuer la fonction à un nom de variable différent et l'appeler via le nouveau nom de variable :

othername=func( )
othername( )
Créer une fonction

La fonction appelable intégrée peut être utilisée pour déterminer si la fonction est appelable :

Copier le code Le code est le suivant :

>>> importer des mathématiques
>>> x=1
>>> ; callable(x)
False
>>> callable(y)
True

Utilisez l'instruction del pour définir une fonction :

Copiez le code Le code est le suivant :

>>> def hello(name):
　　 return 'Bonjour, '+name+' !'
>>> ; imprimer bonjour('world')
Bonjour, tout le monde !
>>> imprimer bonjour('Gumby')
Bonjour, Gumby !

Écrire une fonction de séquence fibnacci :

Copier le code Le code est le suivant :

>>>
résultat=[0,1 )
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
>>> />[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]


Attribuer des valeurs aux paramètres dans une fonction ne changera la valeur d'aucune variable externe :


Copier le code
Le code est le suivant :

>>> :

n='M.Gumby'>> ;> nom='Mme.Entity'>>>

'Mrs.Entity'

Puisque les chaînes (et les tuples et les nombres) sont immuables, elles ne changeront pas lorsqu'elles sont utilisées comme paramètres, mais que se passe-t-il si une structure de données mutable telle qu'une liste est utilisé comme paramètre :


Copier le code
Le code est le suivant :

>>> name='Mrs.Entity'

>>> try_to_change(name)

>>> nom'Mme.Entity'>>> ='M. Gumby'

> ;>> nom=['Mme.Entité','Mme.Thing']
>>> ;>> nom
['Mr. Gumby', 'Mrs.Thing']


Les paramètres ont changé, ce qui constitue une différence importante par rapport à l'exemple précédent

Refaites sans utiliser de fonction :

Copier le code
Le code est le suivant :

>>> Entity','Mrs.Thing']

>>> n=name #Encore une fois, simulez le comportement de passage du paramètre

>>> #Changer la liste

>>> nom

['Mr. Gumby', 'Mrs.Thing']

Lorsque deux variables font référence à une liste en même temps , ils font référence à la même liste en même temps. Pour éviter cette situation, vous pouvez faire une copie de la liste. Lors du découpage dans une séquence, la tranche renvoyée est toujours une copie, donc si vous copiez la tranche entière. liste, vous en recevrez une copie :

Copier le code
Le code est le suivant :


>>> ','Mme.Thing']

>>> n=noms[:]

>> n est un nom

Faux

>>> =namesTrue

Changer n à ce moment n'affectera pas les noms :


Copier le code
Le code est le suivant :

>>> n[0]='M. Gumby'
>>> n
['M.Gumby', 'Mme.Thing']
>>> noms
['Mme.Entity', 'Mrs.Thing']
>>>
['Mrs.Entity', 'Mrs.Thing']

Paramètres de mots clés et valeurs par défaut

L'ordre des paramètres peut être modifié en fournissant des noms de paramètres (mais les paramètres les noms et les valeurs doivent correspondre) :

Copier le code Le code est le suivant :

>>> ):
            imprimer '%s,%s!'%(salutation, nom)
>>> bonjour(salutation='bonjour',nom='monde!')
bonjour,monde !!

La chose la plus puissante à propos des paramètres de mots-clés est que vous pouvez fournir des valeurs par défaut pour les paramètres dans les paramètres :

Copiez le code Le code est comme suit :

>>> def hello_1(greeting='hello',name='world!'):
   print '%s,%s!'%(salutation ,nom)

> >> bonjour_1()

bonjour, monde !!
>>> bonjour_1('Salutations')
Bonjour, monde !!
>>> hello_1(' Greeting','universe')
Salut,univers !

Si vous souhaitez que le message d'accueil utilise la valeur par défaut :

Copiez le code Le code est le suivant :

>>> hello_1(name='Gumby')
bonjour Gumby !

Vous pouvez fournir n'importe quel nombre de paramètres à la fonction, et ce n'est pas facile à mettre en œuvre. Difficulté :

Copier le code

Le code est le suivant :

& gt; & gt; & gt; def print_params (*params):

print params
🎜>>>> )
>>> print_params(1,2,3)

(1, 2, 3)

Mélanger les paramètres communs :

Copier le code

Le code est le suivant :

>>> >>>> print_params_2('params:',1,2,3)params:

(1, 2, 3)

>>> )
Rien :
()

L'astérisque signifie "collecter les paramètres de position restants", si aucun élément n'est fourni pour la collection, params est un tuple vide

mais les paramètres des mots-clés ne peuvent pas être traités :


Copier le code
Le code est le suivant :

>>> print_params_2('Hmm...' ,something=42)

Traceback (dernier appel le plus récent) :

Fichier "", ligne 1, dans

print_params_2('Hmm...',quelque chose =42)TypeError : print_params_2() a obtenu un argument de mot clé inattendu 'quelque chose'

Essayez d'utiliser "**":


Copier le code
Le le code est le suivant :

>>> def print_params(**params):

print params

>>> ,y=2,z=3){'y' : 2, 'x' : 1, 'z' : 3}>>> ,*pospar,**keypar):

　　print x,y,z

　　print pospar
　　print keypar

>>> 6,7,foo=1,bar=2)

1 2 3
(5, 6, 7)
{ 'foo' : 1, 'bar' : 2}
>> ;> paramètres(1,2)
1 2 3
()

{}

>> def print_params_3(**params):
​​​​imprimer les paramètres

>>> print_params_3(x=1,y=2,z=3)
{'y' : 2 , 'x' : 1, 'z' : 3}
>>> #Renvoie un dictionnaire au lieu d'un tuple
>>> #Combinez '#' et '##'
>> 1,2,3,5,6,7,foo=1,bar=2)
1 2 3
(5, 6, 7)

{'foo' : 1, 'bar' : 2}

>>> print_params_4(1,2)
1 2 3
()
{}

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!