Detaillierte Beschreibung der Funktionen in Python

Fibonacci-Folge

>>> 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]

Hinweis: Die integrierte aufrufbare Funktion kann verwendet werden, um zu bestimmen, ob die Funktion aufgerufen werden kann

def Funktion definieren

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

    
>>> hello('world')
Helloworld

Funktion zum Schreiben einer Fibonacci-Folge verwenden

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

        
>>> fibs(10)

Hinweis: Die Return-Anweisung gibt den Wert der Funktion zurück

Funktionsbeschreibung : Wenn Sie Dokumentation für die Funktion schreiben, überlassen Sie es anderen Verstehen Sie es. Wenn ja, können Sie Kommentare hinzufügen (beginnend mit #). Eine andere Möglichkeit besteht darin, die Zeichenfolge direkt zu schreiben.

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

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

Die integrierte Hilfefunktion kann Informationen über die Funktion abrufen, einschließlich ihrer Dokumentationszeichenfolge

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

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

Durch das Zuweisen neuer Werte zu Parametern innerhalb einer Funktion wird der Wert externer Variablen nicht geändert:

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

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

String (sowie Zahlen und Tupel) sind unveränderlich, das heißt, sie können nicht geändert werden. Wenn die veränderbare Datenstruktur (Liste oder Wörterbuch) geändert wird, werden die Parameter geändert

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

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

Schlüsselwortparameter und Standardwerte

>>> 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!

Parameter sammeln

Tupel zurückgeben:

>>> 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)

Wörterbuch zurückgeben

>>> 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
()
{}

Tupel aufrufen, Wörterbuch

>>> 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'])

Das Sternchen ist nur nützlich, wenn eine Funktion definiert wird (die eine unbegrenzte Anzahl von Parametern zulässt) oder sie aufgerufen wird („ein Wörterbuch oder eine Sequenz aufteilen“)

>>> 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

Einige Beispiele

>>> 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)

Globale Variablen ändern

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

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

Verschachtelt

>>> 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)

Rekursion (Aufruf)

Fakultäten und Potenzen

>>> 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)

Binäre Suche

>>> 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)

Kartenfunktion

es Erhalten Sie eine Funktion und eine Liste und wenden Sie die Funktion nacheinander auf jedes Element der Liste an, erhalten Sie eine neue Liste und geben Sie

>>> map(str,range(10))
['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
>>> 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,['ASDF','jskk'])
['Asdf', 'Jskk']

Filterfunktion

Es empfängt eine Funktion und eine Liste (Liste). Diese Funktion beurteilt nacheinander jedes Element und gibt automatisch „True“ oder „False“ zurück, filter() Filtert Elemente heraus, die die Bedingungen nicht erfüllen, basierend auf den Beurteilungsergebnissen, und gibt eine neue Liste zurück, die aus Elementen besteht, die die Bedingungen erfüllen

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

>>> filter(is_not_empty,[None,'dshk','  ','sd'])
['dshk', 'sd']
>>> 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]

Die Lambda-Funktion

wird auch als anonyme Funktion bezeichnet, d. h. die Funktion hat keinen bestimmten Namen, aber die mit def erstellte Methode hat einen Namen

>>> def foo():return 'Begin'

>>> lambda:'begin'
<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(),['8ui','&j','lhg',')j'])
['8ui', 'lhg']

Reduzierfunktion

Es erhält eine Funktion und eine Liste (Liste), die Funktion muss zwei empfangen Parameter, diese Funktion ruft wiederum jedes Element der Liste auf und gibt eine neue Liste zurück, die aus dem Ergebniswert besteht

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

Für detailliertere Beschreibungen der Funktionen in Python und verwandte Artikel, achten Sie bitte auf PHP Chinese Net!