1. cartographier, filtrer, réduire
1) map(func, input_list)
Appliquer la fonction à chaque élément de la liste d'entrée, tel que :
input_list = [1, 2 , 3, 4, 5]
def pow_elem(x):
"""
Développez la puissance de x
:param x:
:return:
"""
return x * x
def multi_x_y(x, y):
return x * y
imprimer la carte(pow_elem , input_list) # sortie :[1, 4, 9, 16, 25]
imprimer la carte(multi_x_y, input_list, input_list) # sortie :[1, 4, 9, 16, 25]
2) filter(func_or_none, séquence)
Filtrez les valeurs de la séquence qui satisfont au retour de fonction True et formez un nouveau retour de séquence, tel que :
def is_odd(x):
"""
Déterminer si x est un nombre impair
:param x:
:return:
"""
return True if x % 2 > 0 else False
print filter(is_odd, input_list) #output: [1, 3, 5]
3) réduire(fonction, séquence)
Les paramètres reçus par la fonction réduire() sont similaires à map( ), une fonction f et une liste, mais le comportement est différent de map(). La fonction f passée à réduire() doit recevoir deux paramètres réduire() appelle à plusieurs reprises la fonction f pour chaque élément de la liste et renvoie le résultat final. valeur. Par exemple : réduire(lambda x, y: x+y, [1, 2, 3, 4, 5]) équivaut à ((((1+2)+3)+4)+5)
imprimer réduire (lambda x, y : x * y, input_list) # sortie : 120
2 Opération ternaire
Les deux manières d'écrire suivantes sont équivalentes :
"Oui" si 2==2. else " Non"
("Non", "Oui")[2==2]
C'est à dire :
1) condition_is_true si condition else condition_is_false
2) (if_test_is_false, if_test_is_true)[test ]
1) et 2) peuvent tous deux implémenter des opérations ternaires, mais 2) est plus rare et moins élégant en même temps, 2) n'est pas une opération de court-circuit, comme suit :
5 si True else 5. /0 # sortie : 5
(1/0, 5)[True] # throw exception-> ZeroDivisionError : division entière ou modulo par zéro
3. nous pouvons le définir à l'intérieur de la fonction function et l'appeler, comme :
def hi(name="patty"):
print("vous êtes maintenant dans la fonction hi()")
return "maintenant vous êtes dans la fonction greet()"
return "maintenant vous êtes dans la fonction Welcome()"
print(welcome())
print("vous êtes maintenant de retour dans la fonction hi()")
Le résultat de sortie est :
vous êtes maintenant à l'intérieur de la fonction hi()
maintenant vous êtes dans la fonction greet()
maintenant vous êtes dans la fonction Welcome()
maintenant vous êtes de retour dans la fonction hi()
def hi(name="patty"):
def greet():
return "maintenant vous êtes dans le fonction greet()"
return "maintenant vous êtes dans la fonction bienvenue()"
print hi() # < ;function greet at 0x109379a28>
print hi()() # maintenant vous êtes dans la fonction greet()
Dans le code ci-dessus, le hi() call renvoie un objet fonction, qui peut être obtenu à partir de l'instruction if/else. On estime que ce qui est renvoyé est la fonction greet(). Lorsque nous appelons hi()(), nous appelons en fait la fonction interne greet().
def hi():
return "salut patty!"
print("Je fais un travail ennuyeux avant d'exécuter hi()")
print(func())
Résultat de sortie :
Je fais un travail ennuyeux avant d'exécuter hi()
salut patty !
Jusqu'à présent, nous avons implémenté un décorateur simple, qui génère une ligne avant d'appeler la fonction hi() Dans les applications réelles, il peut s'agir de quelques opérations de prétraitement. En fait, la fonction du décorateur est d'ajouter des fonctions communes avant et après l'exécution de votre logique de base.
def a_new_decorator(a_func):
print("Je fais un travail ennuyeux avant d'exécuter a_func() " )
print("Je suis la fonction qui a besoin d'une décoration pour éliminer mon odeur nauséabonde")
#outputs: "Je suis la fonction qui a besoin d'une décoration décoration pour enlever mon odeur nauséabonde"
#now a_function_requiring_decoration est enveloppé par wrapTheFunction()
a_function_requiring_decoration()
# Je fais un travail ennuyeux avant d'exécuter a_func()
# Je suis la fonction qui a besoin d'une décoration pour éliminer mon odeur nauséabonde
# Je fais un travail ennuyeux après l'exécution a_func()
5) Formulaire d'annotation
@a_new_decorator
def b_function_requiring_decoration():
print("Je suis une autre fonction qui a besoin d'une décoration pour enlever mon odeur nauséabonde")
b_function_requiring_decoration()
# Je fais un travail ennuyeux avant d'exécuter a_func()
# Je suis une autre fonction qui a besoin d'une décoration pour éliminer mon odeur nauséabonde
# Je fais un travail ennuyeux après avoir exécuté a_func()
Ici @a_new_decorator est équivalent à a_new_decorator(b_function_requiring_decoration)
6) Obtenir le nom
Pour a_function_requiring_decoration en 4), nous imprimons print(a_function_requiring_decoration.__name__) et obtenons Le résultat est wrapTheFunction, mais en réalité ce que nous voulons obtenir, c'est le nom de la fonction a_function_requiring_decoration correspondant à a_func. Python nous fournit des wraps pour résoudre ce problème.
from functools import wraps
def a_new_decorator(a_func):
@wraps(a_func)
def wrapTheFunction():
print("Je fais un travail ennuyeux avant d'exécuter a_func()" )
a_func()
print("Je fais un travail ennuyeux après avoir exécuté a_func()")
return wrapTheFunction
7) Décorateur Certains scénarios d'application
Authentification de l'utilisateur
def require_auth(f):
@wraps(f)
def décoré(*args, **kwargs):
auth = {"username": "patty ", "password": "123456"}
sinon check_auth(auth['username'], auth['password']):
authenticate()
return f(*args, * *kwargs )
def check_auth(username, password):
print "Démarrage de la vérification de l'authentification..."
return True if (username == 'patty' et password == '123456') else False
def Authenticate():
print "Déjà authentifier"
return décoré
@requires_auth
def Welcome():
return " Welcome Patty !"
imprimer bienvenue()
Logging
def logit(func):
@wraps(func)
def with_logging(*args, ** kwargs):
print(func.__name__ + " a été appelé")
return func(*args, **kwargs)
return with_logging
@logit
def addition_func(x ):
"""Faites quelques calculs."""
return x + x
result = addition_func(4)
affichera : addition_func a été appelé
8 ) Décorateur avec paramètres
de functools import wraps
def logit(logfile='out.log'):
def logging_decorator(func):
@wraps( func)
def wrap_function(*args, **kwargs):
log_string = func.__name__ + " was approved"
print(log_string)
# Ouvrez le fichier journal et ajoutez open (logfile, 'a') comme open_file :
>
@logit()
def myfunc1():
pass
# Sortie : myfunc1 a été appelé
# Un fichier appelé out.log existe maintenant, avec la chaîne ci-dessus
def myfunc2():
pass
9) Utiliser la classe comme décorateur
import os
def __init__(self, log_file):
self.log_file = log_file
def __call__(self, func):
avec open(self.log_file, 'a') comme fout:
log_msg = func.__name__ + " a été appelé"
fout.write(log_msg)
>
class EmailLogit(Logit):
''
Une implémentation logit pour envoyer des e-mails aux administrateurs
lorsque la fonction est appelée.
'''
def __init__(self, log_file , email='admin@myproject.com'):
self.email = email
super(EmailLogit, self).__init__(log_file)
def notify(self):
# Envoyer un e-mail à self.email
# Ne sera pas implémenté ici
avec Open (Self.log_file, 'A) comme f :
F.Write ("faire quelque chose...") ; > passer
@EmailLogit("log2.txt")
def myfunc4():
utilisation L'utilisation de classes comme décorateurs rend notre code plus concis et peut également permettre la personnalisation et la réutilisation des fonctions via l'héritage.
4. Types de variables
Les types de variables en Python incluent des listes et des dictionnaires. Les éléments de ces objets sont modifiables, tels que
>>> foo
['salut', 'patty']
>>> ='bonjour'
>>> foo
>>> 🎜>>>> fdict.update({"age":"23"})
>>> fdict
{'age' : '23', 'nom' : 'patty '}
>>> fdict.update({"age":"25"})
>>> fdict
{'âge' : '25' , 'nom' : 'patty'}
Dans la méthode, si le paramètre entrant adopte un type de variable et se voit attribuer une valeur par défaut, veuillez noter que les situations suivantes se produiront :
... target.append(num)
... return target
...
>>> add_to(1)
[1]
>>> add_to(2)
[1, 2]
[1, 2, 3]
En effet, les paramètres par défaut sont calculés lorsque la méthode est définie, plutôt que recalculés à chaque appel. Par conséquent, afin d'éviter la situation ci-dessus, lorsque nous prévoyons de calculer avec une nouvelle liste vide à chaque appel de la méthode, nous pouvons l'écrire comme suit :
>>> Aucun) :
... si la cible est Aucun :
... target = []
... target.append(num)
... return target
...
>>> add_to(1)
[1]
>>> add_to(2)
[2]
5. copy Copy
En Python, il existe des différences entre l'affectation d'objets et la copie (copie profonde/superficielle) Si vous n'y prêtez pas attention lorsque vous l'utilisez, des résultats inattendus peuvent survenir.
1) La méthode par défaut en Python est la méthode de copie superficielle
>>> foo = ['hi']
>>> id (foo)
4458211232
>>> id(bar) bar
['salut', 'patty']
>>> ', 'patty']
>> ;> importer la copie
>>> lent = copy.deepcopy(foo)
>>> : 'patty'}]
>>> slow[0]='bonjour'
>>> ' : 'patty'}]
>>> foo
['hi', {'age' : 20, 'name' : 'patty'}]
Remarque : puisque la lenteur est correcte La copie profonde de foo ouvre en fait un nouvel espace dans la mémoire et copie le contenu référencé par l'objet foo dans le nouvel espace mémoire. Par conséquent, lorsque le contenu référencé par l'objet lent est mis à jour, les modifications ne sont reflétées que sur la référence de. l'objet lent, le contenu référencé par l'objet foo n'a pas changé.
6. Collection
1) defaultdict
Pour un dict ordinaire, si vous obtenez une clé inexistante, une erreur KeyError sera déclenchée, comme suit :
some_dict = {}
some_dict[ 'colours' ]['favourite'] = "jaune"
# Raises KeyError: 'colours'
Mais grâce à defaultdict, nous pouvons éviter cette situation, comme suit :
importer des collections
importer json
tree = lambda : collections.defaultdict(tree)
some_dict = tree()
some_dict['colours']['favourite'] = "jaune"
print json.dumps(some_dict)
# Fonctionne bien, sortie : {"colours": {"favourite": "jaune"}}
2) OrderedDict
OrderedDict peut imprimer le dictionnaire dans l'ordre des touches lorsque nous définissons le dictionnaire et modifier la valeur. Les valeurs ne modifieront pas l'ordre des clés. Cependant, une fois les clés supprimées et réinsérées, les clés seront réorganisées jusqu'à la fin du dict.
à partir des collections importer OrderedDict
colours = OrderedDict([("Red", 198), ("Green", 170), ("Blue", 160)])
pour clé, valeur in colours.items() :
print(key, value)
3) Counter
Utilisez Counter pour compter le nombre d'occurrences d'éléments spécifiques, tels que :
from collections import Counter
couleurs = (
('Yasoob', 'Jaune'),
('Ali', 'Bleu'),
('Arham', 'Vert'),
( 'Ali', 'Noir'),
('Yasoob', 'Rouge'),
('Ahmed', 'Argent'),
)
favs = Counter (nom pour nom, couleur en couleurs)
print(favs)
# Counter({'Yasoob' : 2, 'Ali' : 2, 'Arham' : 1, 'Ahmed' : 1})
4) deque
deque est une file d'attente à double extrémité, qui peut être insérée et supprimée respectivement en tête et en queue, comme suit :
from collections import deque
queue_d = deque()
queue_d.append( 1)
queue_d.append(2)
print queue_d # deque([1, 2])
queue_d.appendleft(3)
print queue_d # deque([3 , 1, 2])
queue_d.pop()
print queue_d # deque([3, 1])
queue_d.popleft()
print queue_d # deque([1] )
deque peut définir la longueur maximale de la file d'attente Lorsque le nombre d'éléments dépasse la longueur maximale, le nombre d'éléments correspondant sera supprimé dans le sens opposé au sens d'insertion actuel, comme suit :
queue_c = deque(maxlen=5, iterable=[2, 4, 6])
queue_c.extend([7, 8])
print queue_c # deque([2, 4, 6, 7, 8 ], maxlen=5)
queue_c.extend([ 10, 12])
print(queue_c) # deque([6, 7, 8, 10, 12], maxlen=5)
queue_c. extendleft([18])
print(queue_c) # deque([18, 6, 7, 8, 10], maxlen=5)
5) nametuple
tuple est une liste immuable. Les éléments du tuple ne peuvent pas être réaffectés. Nous ne pouvons accéder aux éléments du tuple que via l'index. Le nametuple peut être considéré comme un dictionnaire immuable et les éléments du tuple sont accessibles via name. Par exemple :
à partir de collections importez Namedtuple
Animal = Namedtuple('Animal', 'name age type')
perry = Animal(name="perry", age=31, type=" chat ")
print(perry)
# Sortie : Animal(name='perry', age=31, type='cat')
print(perry.name)
# Sortie : 'perry'
print(perry[0])
# Sortie : 'perry'
print(perry._asdict())
# Sortie : OrderedDict ([('name', 'perry'), ('age', 31), ('type', 'cat')])
7. Introspection d'objet
1) dir : Liste les Toutes les méthodes de l'objet
2) type : renvoie le type de l'objet
3) id : renvoie l'identifiant de l'objet
8 Générateur
1) liste
. >>> ; au carré = [x**2 pour x dans la plage (10)]
>>> au carré
[0, 1, 4, 9, 16, 25, 36, 49 , 64, 81]
2) dict
{v : k pour k, v dans some_dict.items()}
3) set
>>> au carré = {x** 2 pour x dans la plage (10)}
>>> au carré
set([0, 1, 4, 81, 64, 9, 16, 49, 25, 36])
9. Traitement des exceptions
essayez :
print('Je suis sûr qu'aucune exception ne se produira !')
sauf Exception :
print('exception')
else :
# tout code qui ne doit s'exécuter que si aucune exception ne se produit lors de l'essai,
# mais pour lequel les exceptions ne doivent PAS être interceptées
print('Cela ne s'exécutera que si aucune exception ne se produit. Et une erreur ici '
'ne serait PAS attrapé.')
finally:
print('Ceci serait imprimé dans tous les cas.')
# Sortie : je suis sûr qu'aucune exception ne se produira !
# Cela ne s'exécuterait que si aucune exception ne se produit.
# Ceci serait imprimé dans tous les cas. Les instructions dans
else seront exécutées avant finalement.
10. Méthode intégrée
a_list = [[1, 2], [3, 4], [5, 6]]
print(list(itertools.chain.from_iterable(a_list )) )
# Sortie : [1, 2, 3, 4, 5, 6]
# ou
print(list(itertools.chain(*a_list)))
# Sortie : [1, 2, 3, 4, 5, 6]
class A(object):
def __init__(self, a, b, c, d, e, f):
self.__dict__.update({k: v pour k, v in locals().items() if k != 'self'})
11. instruction for-else
Il existe deux manières normales de terminer l'instruction for : l'une est lorsque des conditions spécifiques sont remplies La pause suivante consiste à sortir de la boucle et la seconde à mettre fin à toutes les boucles conditionnelles. L'instruction else dans for-else ne sera exécutée que lorsque toutes les conditions auront été jugées et que la boucle for se terminera normalement, comme suit :
for x in range(1, 10, 2):
if x % 2 = = 0 :
print "trouvé même sur %d"%x
break
else:
print "pas trouvé même"
# sortie : pas trouvé même
12 . Compatible avec Python 2+ et Python 3+
1) Utilisez le module __future__ pour référencer les modules Python 3+ dans un environnement Python 2+
2) Méthodes d'importation de modules compatibles
essayez :
import urllib. .request as urllib_request # pour Python 3
sauf ImportError :
import urllib2 as urllib_request # pour Python 2
Référence :
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!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
