Maison  >  Article  >  développement back-end  >  Description détaillée des fonctions en python

Description détaillée des fonctions en python

高洛峰
高洛峰original
2017-03-08 10:17:071576parcourir

Séquence de Fibonacci

>>> fibs
[0, 1]>>> n=input('How many Fibonacci numbers do your what?')
How many Fibonacci numbers do your what?10
>>> for n in range(n-2):
    fibs.append(fibs[-2]+fibs[-1])    
>>> fibs
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

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

def Définir la fonction

>>> def hello(name):
    print "Hello"+name

    
>>> hello('world')
Helloworld

Utiliser la fonction pour écrire la séquence de Fibonacci

>>> def fibs(num):
    s=[0,1]
    for i in range(num-2):
        s.append(s[-2]+s[-1])

        
>>> fibs(10)

Remarque : L'instruction return renvoie la valeur de la fonction

Description de la fonction  : Si vous écrivez une documentation pour la fonction, laissez les autres comprenez-le Si c'est le cas, vous pouvez ajouter des commentaires (en commençant par #). Une autre façon consiste à écrire la chaîne directement.

>>> def square(x):
    'Calculates the square of the number x.'
    return x*x

>>> square.__doc__
'Calculates the square of the number x.'

La fonction d'aide intégrée peut obtenir des informations sur la fonction, y compris sa chaîne de documentation

>>> help(square)
Help on function square in module __main__:

square(x)
    Calculates the square of the number x.

L'attribution de nouvelles valeurs aux paramètres d'une fonction ne modifiera pas la valeur des variables externes :

>>> def try_to_change(n):
    n='Mr,Gumby'

    
>>> name='Mrs,Entity'
>>> try_to_change(name)
>>> name
'Mrs,Entity'

String (ainsi que les nombres et les tuples) sont immuables, c'est-à-dire qu'ils ne peuvent pas être modifiés. Si la structure de données modifiable (liste ou dictionnaire) est modifiée, les paramètres seront modifiés

>>> n=['Bob','Alen']
>>> def change(m):
    m[0]='Sandy'

    
>>> change(n[:])
>>> n
['Bob', 'Alen']
>>> change(n)
>>> n
['Sandy', 'Alen']

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

>>> def hello(name,greeting='Hello',punctuation='!'):
    print '%s,%s%s' % (greeting,name,punctuation)

    
>>> hello(name='Nsds')
Hello,Nsds!
>>> hello(name='Nsds',greeting='Hi')
Hi,Nsds!

Collecter les paramètres

Tuple de retour :

>>> def print_params(*params):
    print params

    
>>> print_params('Testing') #返回元组
('Testing',)
>>> print_params(1,2,3)
(1, 2, 3)
>>> def print_params_2(title,*params):
    print title
    print params

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

Retourner le dictionnaire

>>> def print_params_3(**params):
    print params

    
>>> print_params_3(x=1,y=2,z=3)
{'y': 2, 'x': 1, 'z': 3}
>>> def print_params_4(x,y,z=3,*pospar,**keypar):
    print x,y,z
    print pospar
    print keypar

    
>>> print_params_4(1,2,3,5,6,7,foo=1,bar=2)
2 3
(5, 6, 7)
{'foo': 1, 'bar': 2}
>>> print_params_4(1,2)
2 3
()
{}

Appeler le tuple, le dictionnaire

>>> def add(x,y):return x+y

>>> params=(1,2)
>>> add(*params)
>>> def with_stars(**kwds):
    print kwds['name'],'is',kwds['age'],'years old']
>>> def without_starts(kwds):
    print kwds['name'],'is',kwds['age'],'years old'
>>> args={'name':'Nsds','age':24}
>>> with_stars(**args)
Nsds is 24 years old
>>> without_starts(args)
Nsds is 24 years old
>>> add(2,args['age'])

L'astérisque n'est utile que lors de la définition d'une fonction (autorisant un nombre indéfini de paramètres) ou de son appel ("diviser" un dictionnaire ou une séquence)

>>> def foo(x,y,z,m=0,n=0):
    print x,y,z,m,n

    
>>> def call_foo(*args,**kwds):
    print "Calling foo!"
    foo(*args,**kwds)

>>> d=(1,3,4)
>>> f={'m':'Hi','n':'Hello'}
>>> foo(*d,**f)
3 4 Hi Hello
>>> call_foo(*d,**f)
Calling foo!
3 4 Hi Hello

Plusieurs exemples

>>> def story(**kwds):
    return 'Once upon a time,there was a' \
           '%(job)s called %(name)s.' % kwds

>>> def power(x,y,*others):
    if others:
        print 'Received redundant parameters:',others
    return pow(x,y)

>>> def interval(start,stop=None,step=1):
    if stop is None:
        start,stop=0,start  #start=0,stop=start
    result=[]
    i=start
    while i<stop:
        result.append(i)
        i+=step
    return result

>>> print story(job=&#39;king&#39;,name=&#39;Gumby&#39;)
Once upon a time,there was aking called Gumby.
>>> print story(name=&#39;Sir Robin&#39;,job=&#39;brave knight&#39;)
Once upon a time,there was abrave knight called Sir Robin.
>>> params={&#39;job&#39;:&#39;language&#39;,&#39;name&#39;:&#39;Python&#39;}
>>> print story(**params)
Once upon a time,there was alanguage called Python.
>>> del params[&#39;job&#39;]
>>> print story(job=&#39;store of genius&#39;,**params)
Once upon a time,there was astore of genius called Python.
>>> power(2,3)
>>> power(y=3,x=2)
>>> params=(5,)*2
>>> power(*params)
>>> power(3,3,&#39;Helld,world&#39;)
Received redundant parameters: (&#39;Helld,world&#39;,)
>>> interval(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> interval(1,5)
[1, 2, 3, 4]
>>> power(*interval(3,7))
Received redundant parameters: (5, 6)

Modifier des variables globales

>>> def f():
    global x
    x=x+1

    
>>> f()
>>> x
>>> f()
>>> x

Imbriqué

>>> def multiplier(factor):
    def multiplyByFactor(number):
        return number*factor
    return multiplyByFactor

>>> double=multiplier(2)
>>> double(5)
>>> multiplier(2*5)
<function multiplyByFactor at 0x0000000002F8C6D8>
>>> multiplier(2)(5)

Récursion (appel)

Factoriales et puissances

>>> def factorial(n):
    if n==1:
        return 1
    else:
        return n*factorial(n-1)
    
>>> factorial(5)
>>> range(3)
[0, 1, 2]
>>> def power(x,n):
    result=1
    for i in range(n):
        result *= x
    return result
>>> power(5,3)

>>> def power(x,n):
    if n==0:
        return 1
    else:
        return x*power(x,n-1)

    
>>> power(2,3)


Recherche binaire

>>> def search(s,n,min=0,max=0):
    if max==0:
        max=len(s)-1
    if min==max:
        assert n==s[max]
        return max
    else:
        middle=(min+max)/2
        if n>s[middle]:
            return search(s,n,middle+1,max)
        else:
            return search(s,n,min,middle)

        
>>> search(seq,100)

fonction de carte

it Recevoir une fonction et une liste, et appliquez la fonction à chaque élément de la liste tour à tour, obtenez une nouvelle liste et revenez

>>> map(str,range(10))
[&#39;0&#39;, &#39;1&#39;, &#39;2&#39;, &#39;3&#39;, &#39;4&#39;, &#39;5&#39;, &#39;6&#39;, &#39;7&#39;, &#39;8&#39;, &#39;9&#39;]
>>> def f(x):
    return x*x

>>> print map(f,[1,2,3,4,5,6,7])
[1, 4, 9, 16, 25, 36, 49]

>>> def format_name(s):
    s1=s[0].upper()+s[1:].lower()
    return s1

>>> print map(format_name,[&#39;ASDF&#39;,&#39;jskk&#39;])
[&#39;Asdf&#39;, &#39;Jskk&#39;]

fonction de filtrage

Elle reçoit une fonction et une liste (liste). Cette fonction juge chaque élément tour à tour et renvoie automatiquement Vrai ou Faux, filter(). filtre les éléments qui ne remplissent pas les conditions en fonction des résultats du jugement et renvoie une nouvelle liste composée d'éléments qui remplissent les conditions

>>> def is_not_empty(s):
    return s and len(s.strip())>0

>>> filter(is_not_empty,[None,&#39;dshk&#39;,&#39;  &#39;,&#39;sd&#39;])
[&#39;dshk&#39;, &#39;sd&#39;]
>>> def pfg(x):
    s=math.sqrt(x)
    if s%1==0:
        return x

>>> import math
>>> pfg(100)
>>> pfg(5)
>>> filter(pfg,range(100))
[1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> def is_sqr(x):
    return math.sqrt(x)%1==0

>>> is_sqr(100)
True
>>> filter(is_sqr,range(100))
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

La fonction Lambda

est également appelée fonction anonyme, c'est-à-dire que la fonction n'a pas de nom spécifique, mais la méthode créée avec def a un nom

>>> def foo():return &#39;Begin&#39;

>>> lambda:&#39;begin&#39;
<function <lambda> at 0x0000000002ECC2E8>
>>> s=lambda:&#39;begin&#39;
>>> print s()
begin
>>> s= lambda x,y:x+y
>>> print s(1,2)
>>> def sum(x,y=6):return x+y

>>> sum2=lambda x,y=6:x+y
>>> sum2(4)

>>> filter(lambda x:x*x,range(1,5))
[1, 2, 3, 4]>>> map(lambda x:x*x,range(1,5))
[1, 4, 9, 16]>>> filter(lambda x:x.isalnum(),[&#39;8ui&#39;,&#39;&j&#39;,&#39;lhg&#39;,&#39;)j&#39;])
[&#39;8ui&#39;, &#39;lhg&#39;]

fonction de réduction

Elle reçoit une fonction et une liste (liste), la fonction doit en recevoir deux paramètres, cette fonction appelle à son tour chaque élément de la liste et renvoie une nouvelle liste composée de la valeur du résultat

>>> reduce(lambda x,y:x*y,range(1,5))
24
>>> reduce(lambda x,y:x+y,[23,9,5,6],100) #初始值为100,依次相加列表中的值
143

Pour des descriptions plus détaillées des fonctions dans python et articles connexes, veuillez faire attention à PHP Chinese net !

Déclaration:
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn