


Fonctions de code d'apprentissage de base Python et programmation fonctionnelle
def func1(): print 'hello world' res = func1() print type(res) def func2(): return ['xyz',10000,-98] atuple = func2() x,y,z = func2() print x,y,z def func3(): return 'xyz',1000,-98 x,y,z = func3() print x,y,z def func4(): return ['xyz',1000,-98,'xxx'] x,y,z,d = func4() alist = x,y,z,d print alist true = lambda :True print true() sum = lambda x,y:x + y summ = lambda x,y=4:x + y atuplet = lambda *zaz:zaz print atuplet('a',1) adictt = lambda **z:z print adictt(x=3,y=5) from random import randint def functest(arg): return arg % 2 allnums = [] for eachnum in range(9): allnums.append(eachnum) print filter(functest,allnums) allnums = [] for eachnum in range(9): # print eachnum ra = randint(1,99) # print ra allnums.append(ra) #print filter(lambda x:x%2,allnums) #print [i for i in allnums if i%2] print [n for n in [randint(1,99) for i in range(9)] if n%2] print map(lambda x:x+2,[i for i in range(9)]) print map(lambda x:x**2,[int(i) for i in range(9)]) print map(str,[i for i in range(9)]) print map(lambda x,y:x+y,[1,2,3],[1,2,3]) print map(lambda x,y:(x+y,x-y),[1,2,3],[1,2,3]) print map(None,[1,2,3],[1,2,3]) print reduce(lambda x,y:x+y,[i for i in range(3)]) from operator import mul,add from functools import partial add1 = partial(add,1) mul100 = partial(mul,100) basetwo = partial(int,base=2) basetwo.__doc__ = 'convert base 2 string to an int' print basetwo('10010') import Tkinter root = Tkinter.Tk() mybutton = partial(Tkinter.Button,root,fg='white',bg='blue') b1 = mybutton(text='button1') b2 = mybutton(text='button2') qb = mybutton(text='quit',bg='red',command=root.quit) b1.pack() b2.pack() qb.pack(fill=Tkinter.X,expand=True) root.title('pfas!') root.mainloop() is_this_global = 'xyz' def foo(): global is_this_global this_is_local = 'abc' is_this_global = 'def' print this_is_local + is_this_global def foor(): m = 3 def bar(): n = 4 print m + n print m bar() def counter(start=0): count = [start] def incr(): count[0] += 1 return count[0] return incr count = counter() output = '<int %r id=%#0x val=%d>' w = x = y = z = 1 def f1(): x = y = z = 2 def f2(): y = z = 3 def f3(): z = 4 print output%('w',id(w),w) print output%('x',id(x),x) print output%('y',id(y),y) print output%('z',id(z),z) clo = f3.func_closure if clo: print 'f3 closure vars:',[str(c) for c in clo] else: print 'no f3 closure vars' f3() clo = f2.func_closure if clo: print 'f2 closure vars:',[str(c) for c in clo] else: print 'no f2 closure vars' f2() clo = f1.func_closure if clo: print 'f1 closure vars:',[str(c) for c in clo] else: print 'no f1 closure vars' from time import time def logged(when): def log(f,*args,**kargs): print '''called: function:%s args:%s kargs:%s'''%(f,args,kargs) def pre_logged(f): def wrapper(*args,**kargs): log(f,*args,**kargs) return f(*args,**kargs) return wrapper def post_logged(f): def wrapper(*args,**kargs): now = time() try: return f(*args,**kargs) finally: log(f,*args,**kargs) print 'time delta:%s' % (time()-now) return wrapper try: return {'pre':pre_logged,'post':post_logged}[when] except KeyError,e: raise ValueError(e),"must be 'pre' or 'post'" @logged('post') def hello(name): print 'hello,',name hello('world!') x = 10 def ffoo(): y = 5 bar = lambda z:x+z print bar(y) j,k = 1,2 def proc1(): j,k = 3,4 print 'j==%d and k==%d' % (j,k) def proc2(): j = 6 proc1() print 'j==%d and k==%d' % (j,k) k = 7 proc1() print 'j==%d and k==%d' % (j,k) j = 8 proc2() print 'j==%d and k==%d' % (j,k) def max2(arg1,arg2): if arg1 > arg2: return arg1 elif arg1 == arg2: return 'equal' else: return arg2 max22 = lambda a,b:a if a > b else b min22 = lambda a,b:a if a < b else b def heji(a,b): return a+b,a*b x,y = heji(3,4) def mymin(a,b,*num): minnum = min22(a,b) for each in num: minnum = min22(minnum,each) return minnum def mymax(a,b,*num): maxnum = max22(a,b) for each in num: maxnum = max22(maxnum,each) return maxnum trantime = lambda m:(unicode(m / 60),unicode(m % 60)) print ':'.join(trantime(80)) a = ['jia','wo','ma'] b = ['get','hoa','?'] print map(None,a,b) print zip(a,b) def oddyear(y): if (y % 4 == 0 and y % 100 != 0) or y % 400 == 0: return y print filter(oddyear,range(1999,2030)) print [y for y in range(1999,2030) if (y % 4 == 0 and y % 100 != 0) or y % 400 == 0] print reduce(lambda x,y:x+y,range(6)) / float(6) cl = lambda x:x.strip() res = map(cl,open('e:\\thefile.txt')) import time def timeit(arg): starttime = time.clock() result = arg endtime = time.clock() return (result,endtime-starttime) def arg(a,b): return a * b print timeit(arg(3,4)) mult = lambda x,y:x * y print reduce(mult,range(9)[1:])
以上就是Python基础学习代码之函数和函数式编程的内容,更多相关内容请关注PHP中文网(www.php.cn)!

Outils d'IA chauds

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool
Images de déshabillage gratuites

Clothoff.io
Dissolvant de vêtements AI

AI Hentai Generator
Générez AI Hentai gratuitement.

Article chaud

Outils chauds

Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

Le langage Go propose deux technologies de création de fonctions dynamiques : la fermeture et la réflexion. les fermetures permettent d'accéder aux variables dans la portée de la fermeture, et la réflexion peut créer de nouvelles fonctions à l'aide de la fonction FuncOf. Ces technologies sont utiles pour personnaliser les routeurs HTTP, mettre en œuvre des systèmes hautement personnalisables et créer des composants enfichables.

Dans la dénomination des fonctions C++, il est crucial de prendre en compte l’ordre des paramètres pour améliorer la lisibilité, réduire les erreurs et faciliter la refactorisation. Les conventions courantes d'ordre des paramètres incluent : action-objet, objet-action, signification sémantique et conformité de la bibliothèque standard. L'ordre optimal dépend de l'objectif de la fonction, des types de paramètres, de la confusion potentielle et des conventions du langage.

La clé pour écrire des fonctions Java efficaces et maintenables est la suivante : restez simple. Utilisez un nom significatif. Gérer des situations particulières. Utilisez une visibilité appropriée.

1. La fonction SOMME permet de sommer les nombres d'une colonne ou d'un groupe de cellules, par exemple : =SOMME(A1:J10). 2. La fonction MOYENNE permet de calculer la moyenne des nombres dans une colonne ou un groupe de cellules, par exemple : =AVERAGE(A1:A10). 3. Fonction COUNT, utilisée pour compter le nombre de nombres ou de texte dans une colonne ou un groupe de cellules, par exemple : =COUNT(A1:A10) 4. Fonction IF, utilisée pour effectuer des jugements logiques basés sur des conditions spécifiées et renvoyer le résultat correspondant.

La gestion des exceptions en C++ peut être améliorée grâce à des classes d'exceptions personnalisées qui fournissent des messages d'erreur spécifiques, des informations contextuelles et effectuent des actions personnalisées en fonction du type d'erreur. Définissez une classe d'exception héritée de std::exception pour fournir des informations d'erreur spécifiques. Utilisez le mot-clé throw pour lancer une exception personnalisée. Utilisez Dynamic_cast dans un bloc try-catch pour convertir l'exception interceptée en un type d'exception personnalisé. Dans le cas réel, la fonction open_file lève une exception FileNotFoundException. La capture et la gestion de l'exception peuvent fournir un message d'erreur plus spécifique.

Lors du passage d'une carte à une fonction dans Go, une copie sera créée par défaut et les modifications apportées à la copie n'affecteront pas la carte d'origine. Si vous devez modifier la carte originale, vous pouvez la passer via un pointeur. Les cartes vides doivent être manipulées avec précaution, car ce sont techniquement des pointeurs nuls, et passer une carte vide à une fonction qui attend une carte non vide provoquera une erreur.

Il existe cinq erreurs et pièges courants dont il faut être conscient lors de l'utilisation de la programmation fonctionnelle dans Go : Évitez toute modification accidentelle des références et assurez-vous que les variables nouvellement créées sont renvoyées. Pour résoudre les problèmes de concurrence, utilisez des mécanismes de synchronisation ou évitez de capturer un état mutable externe. Utilisez la fonctionnalisation partielle avec parcimonie pour améliorer la lisibilité et la maintenabilité du code. Gérez toujours les erreurs dans les fonctions pour garantir la robustesse de votre application. Tenez compte de l'impact sur les performances et optimisez votre code à l'aide de fonctions en ligne, de structures de données aplaties et de lots d'opérations.

Les avantages de la programmation fonctionnelle Java incluent la simplicité, la composabilité, la concurrence, la convivialité des tests et les performances. Les inconvénients incluent la courbe d'apprentissage, la difficulté de débogage, la flexibilité limitée et la surcharge de performances. Ses fonctionnalités clés incluent des fonctions pures sans effets secondaires, des pipelines de traitement de données, du code sans état et des API de streaming efficaces.
