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')
HelloworldUtiliser 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 HelloPlusieurs 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='king',name='Gumby')
Once upon a time,there was aking called Gumby.
>>> print story(name='Sir Robin',job='brave knight')
Once upon a time,there was abrave knight called Sir Robin.
>>> params={'job':'language','name':'Python'}
>>> print story(**params)
Once upon a time,there was alanguage called Python.
>>> del params['job']
>>> print story(job='store of genius',**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,'Helld,world')
Received redundant parameters: ('Helld,world',)
>>> 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()
>>> xImbriqué
>>> 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))
['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']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,'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]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 'Begin' >>> lambda:'begin' <function <lambda> at 0x0000000002ECC2E8> >>> s=lambda:'begin' >>> 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']
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 !
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
