Fassen Sie zusammen, worauf Sie beim Codieren in Python achten müssen

1. Zuordnen, Filtern, Reduzieren
1) map(func, input_list)
Wenden Sie die Funktion auf jedes Element in der Eingabeliste an, z. B.:
input_list = [1, 2 , 3, 4, 5]

def pow_elem(x):
"""
Erweitern Sie die Potenz von x
:param x:
:return:
"""
return x * x

def multi_x_y(x, y):
return x * y

print map(pow_elem , input_list) # Ausgabe:[1, 4, 9, 16, 25]

print map(multi_x_y, input_list, input_list) # Ausgabe:[1, 4, 9, 16, 25]

2) filter(func_or_none, sequence)
Filtern Sie die Werte in der Sequenz heraus, die die Funktion return True erfüllen, und bilden Sie eine neue Sequenz return, wie zum Beispiel:
def is_odd(x):
"""
Bestimmen Sie, ob x eine ungerade Zahl ist
:param x:
:return:
"""
return True if x % 2 > 0 else False

print filter(is_odd, input_list) #output: [1, 3, 5]

3) Reduce(function, sequence)
Die von der Funktion Reduce() empfangenen Parameter ähneln map( ), eine Funktion f und eine Liste, aber das Verhalten unterscheidet sich von map(). Die an Reduce() übergebene Funktion f muss wiederholt zwei Parameter empfangen und die Funktion f für jedes Element der Liste zurückgeben Wert. Zum Beispiel: Reduce(Lambda x, y: x+y, [1, 2, 3, 4, 5]) ist äquivalent zu ((((1+2)+3)+4)+5)
print Reduce (Lambda x, y: x * y, input_list) # Ausgabe: 120

2. Ternäre Operation
Die folgenden zwei Schreibweisen sind äquivalent:
„Ja“, wenn 2==2 else „Nein“
(„Nein“, „Ja“)[2==2]
Das heißt:
1) Bedingung_ist_wahr, wenn Bedingung sonst Bedingung_ist_false
2) (if_test_is_false, if_test_is_true)[test ]
1) und 2) können beide ternäre Operationen implementieren, aber 2) ist seltener und weniger elegant. Gleichzeitig ist 2) keine Kurzschlussoperation, wie folgt:
5 wenn wahr, sonst 5 /0 # Ausgabe: 5
(1/0, 5)[True] # Ausnahme auslösen-> ZeroDivisionError: Ganzzahldivision oder Modulo durch Null

3) In Python, Wir können es innerhalb der Funktion function definieren und aufrufen, wie zum Beispiel:
def hi(name="patty"):
print("now you are inside the hi() function")

def meet():

return „Jetzt bist du in der Funktion „greet()““

def willkommen():

return „jetzt bist du in der Funktion „welcome()““

print(greet())

print(welcome())
print("jetzt sind Sie wieder in der hi()-Funktion")
Das Ausgabeergebnis ist:
jetzt sind Sie es innerhalb der hi()-Funktion
Jetzt sind Sie in der Greet()-Funktion
Jetzt sind Sie in der Welcome()-Funktion
Jetzt sind Sie wieder in der hi()-Funktion

2 ) Sie können auch die interne Funktion zurückgeben und die externe Funktion zum Aufrufen verwenden, wie zum Beispiel:

def hi(name="patty"):
def meet():
return "now you are in the Greet()-Funktion“

def willkommen ():

Rückgabe „Jetzt sind Sie in der Funktion „Willkommen()““

Rückgabe „Greet“ wenn Name == „Patty“, sonst „Willkommen“

print hi() # < ;Funktionsgrüße bei 0x109379a28>
print hi()() # Jetzt befinden Sie sich in der Funktion „greet()“
Im obigen Code ist hi() Der Aufruf gibt ein Funktionsobjekt zurück, das aus der if/else-Anweisung abgerufen werden kann. Es wird davon ausgegangen, dass es sich bei der zurückgegebenen Funktion um die Funktion „greet()“ handelt. Wenn wir hi()() aufrufen, rufen wir tatsächlich die interne Funktion „greet()“ auf.

3) Übergeben Sie die Funktion als Parameter an eine andere Funktion, wie zum Beispiel:

def hi():
return "hi patty!"

def doSomethingBeforeHi(func):

print("Ich mache einige langweilige Arbeit, bevor ich hi() ausführe")
print(func())

doSomethingBeforeHi(hi)

Ausgabeergebnis:
Ich mache einige langweilige Arbeiten vor der Ausführung von hi()
Hi Patty!
Bisher haben wir einen einfachen Dekorator implementiert, der eine Zeile ausgibt, bevor die Funktion hi() aufgerufen wird. In tatsächlichen Anwendungen kann es sich um einige Vorverarbeitungsvorgänge handeln. Tatsächlich besteht die Funktion des Dekorators darin, vor und nach der Ausführung Ihrer Kernlogik einige allgemeine Funktionen hinzuzufügen.

4) Implementierung eines einfachen Dekorators

def a_new_decorator(a_func):

def wrapTheFunction():

print("Ich mache einige langweilige Arbeit, bevor ich a_func() ausführe" )

a_func() # rufe diese Funktion auf

print("Ich erledige langweilige Arbeit, nachdem ich a_func() ausgeführt habe")

return wrapTheFunction

def a_function_requiring_decoration():

print("Ich bin die Funktion, die etwas Dekoration braucht, um meinen üblen Geruch zu entfernen")

a_function_requiring_decoration()

#outputs: "Ich bin die Funktion, die etwas Dekoration braucht Dekoration, um meinen üblen Geruch zu entfernen"

a_function_requiring_decoration = a_new_decorator(a_function_requiring_decoration)

#now a_function_requiring_decoration wird von wrapTheFunction() umschlossen

a_function_requiring_decoration()
# Ich erledige langweilige Arbeit, bevor ich a_func() ausführe
# Ich bin die Funktion, die etwas Dekoration braucht, um meinen üblen Geruch zu entfernen
# Ich erledige langweilige Arbeit nach der Ausführung a_func()

5) Anmerkungsformular
@a_new_decorator
def b_function_requiring_decoration():
print("Ich bin die andere Funktion, die etwas Dekoration braucht, um meinen üblen Geruch zu entfernen")

b_function_requiring_decoration()
# Ich erledige langweilige Arbeit, bevor ich a_func() ausführe
# Ich bin die andere Funktion, die etwas Dekoration braucht, um meinen üblen Geruch zu entfernen
# Ich erledige langweilige Arbeit nach der Ausführung von a_func()
Hier entspricht @a_new_decorator a_new_decorator(b_function_requiring_decoration)

6) Name abrufen
Für a_function_requiring_decoration in 4) drucken wir print(a_function_requiring_decoration.__name__) und erhalten Das Ergebnis ist wrapTheFunction, aber eigentlich wollen wir den Funktionsnamen a_function_requireing_decoration erhalten, der a_func entspricht. Python stellt uns Wraps zur Verfügung, um dieses Problem zu lösen.
from functools import wraps
def a_new_decorator(a_func):
@wraps(a_func)
def wrapTheFunction():
print("Ich mache ein paar langweilige Arbeiten, bevor ich a_func() ausführe" )

a_func()

print("Ich mache einige langweilige Arbeit, nachdem ich a_func() ausgeführt habe")

return wrapTheFunction

7) Dekorateur Einige Anwendungsszenarien
Benutzerauthentifizierung
def erfordert_auth(f):
@wraps(f)
def dekoriert(*args, **kwargs):
auth = {"username": "patty ", "password": "123456"🎜> wenn nicht check_auth(auth['username'], auth['password']):
authenticate()
return f(*args, * *kwargs )

def check_auth(Benutzername, Passwort):

print "Starting check auth..."
return True if (username == 'patty' and password == '123456') else False

def Authenticate():
print „Bereits authentifiziert“
Return dekoriert

@requires_auth

def Welcome():
Return „ Willkommen Patty !"

print Welcome()

Logging

def logit(func):
@wraps(func)
def with_logging(*args, ** kwargs):
print(func.__name__ + " wurde aufgerufen")
return func(*args, **kwargs)
return with_logging

@logit

def Addition_func(x ):
„Machen Sie etwas Mathe.““
return x + ) Decorator mit Parametern
von functools import wraps

def logit(logfile='out.log'):
def logging_decorator(func):
@wraps( func)

def Wrapped_function(*args, **kwargs):

log_string = func.__name__ + " wurde aufgerufen"
print(log_string)

# Öffnen Sie die Protokolldatei und fügen Sie

mit open (logfile, 'a' ) als geöffnete_Datei:
                                                                                                                                                                                                                                 ​>
@logit()
def myfunc1():
pass

myfunc1()
# Ausgabe: myfunc1 wurde aufgerufen
# Es existiert jetzt eine Datei namens out.log mit der obigen Zeichenfolge

@logit(logfile='func2.log')
def myfunc2():

pass

myfunc2( )

9) Klasse als Dekorator verwenden

import os
class Logit(object):
def __init__(self, log_file):

self.log_file = log_file

def __call__(self, func):
with open(self.log_file, 'a') as fout:

log_msg = func.__name__ + " wurde aufgerufen"

fout.write(log_msg)

fout.write(os.linesep)

# Jetzt eine Benachrichtigung senden
self.notify()

def notify(self):
# logit nur protokolliert, nicht mehr

Bestehen

Klasse EmailLogit(Logit):
''
Eine Logit-Implementierung zum Senden von E-Mails an Administratoren
wenn die Funktion aufgerufen wird.
'''
def __init__(self, log_file , email='admin@myproject.com'):
self.email = email
super(EmailLogit, self).__init__(log_file)

def notify(self):
# Senden eine E-Mail an self.email
# Wird hier nicht implementiert
mit Open (Self.log_file, 'A) as f:
F.Write ("tun Sie etwas ...")                                                                                                                                                                                                   ; ("log1.txt")
def myfunc3 ():
pass

@EmailLogit("log2.txt")

def myfunc4():
pass
Verwendung Die Verwendung von Klassen als Dekoratoren lässt unseren Code prägnanter aussehen und kann durch Vererbung auch eine Personalisierung und Wiederverwendung von Funktionen erreichen.

4. Variablentypen in Python umfassen Listen und Wörterbücher, wie z. B.

>>> >>>> foo += ['patty']
>>> ='hello'
>>> foo
['hello', 'patty']

>>> 🎜>>>> fdict.update({"age":"23"})
>>>{'age': '23', 'name': 'patty '}
>>> fdict.update({"age":"25"})
>>> : 'patty'🎜>
Wenn in der Methode der eingehende Parameter einen Variablentyp annimmt und ihm ein Standardwert zugewiesen wird, beachten Sie bitte, dass die folgenden Situationen auftreten:
>>> (num, target=[]):
... target.append(num)
... return target
...

>>> >[1]

>>> add_to(2)
[1, 2]
>>> add_to(3)
[1, 2, 3]
Dies liegt daran, dass die Standardparameter bei der Definition der Methode berechnet werden und nicht bei jedem Aufruf erneut berechnet werden. Um die obige Situation zu vermeiden, können wir daher, wenn wir erwarten, bei jedem Aufruf der Methode mit einer neuen leeren Liste zu rechnen, diese wie folgt schreiben:
>>> None):
... wenn das Ziel None ist:

... target = []

... target.append(num)
... return target
...
>>> add_to(1)
>>> add_to(2)
[2]

5 copy Copy
In Python gibt es Unterschiede zwischen Objektzuweisung und Kopieren (tiefe/flache Kopie). Wenn Sie bei der Verwendung nicht aufpassen, können unerwartete Ergebnisse auftreten.
1) Die Standardeinstellung in Python ist die flache Kopiermethode
>>> foo = ['hi']
>>> id (foo)
4458211232
>>> id(bar) bar
['hi', 'patty']
>>> ', 'patty']
Hinweis: id(foo)==id(bar) , was darauf hinweist, dass foo und bar auf dasselbe Objekt verweisen, wenn die Anhängeoperation für die Liste über die bar-Referenz ausgeführt wird foo stimmt mit dem von bar überein, da es auf denselben Speicherplatz verweist.

2) Deep copy
>>> foo
['hi', {'age': 20, 'name': 'patty'}]
>> ;> import copy

>>> slow = copy.deepcopy(foo)

>>> : 'patty'}]
>>> slow[0]='hello'
>>> slow
['hello', {'age': 20, 'name ': 'patty'}]
>>> foo
['hi', {'age': 20, 'name': 'patty'}]
Hinweis: Da langsam richtig ist Die tiefe Kopie von foo öffnet tatsächlich einen neuen Bereich im Speicher und kopiert den vom foo-Objekt referenzierten Inhalt in den neuen Speicherbereich. Wenn der vom langsamen Objekt referenzierte Inhalt aktualisiert wird, werden die Änderungen daher nur in der Referenz von widergespiegelt Beim langsamen Objekt hat sich der vom foo-Objekt referenzierte Inhalt nicht geändert.

6. Sammlung
1) defaultdict
Wenn Sie bei einem normalen Diktat einen nicht vorhandenen Schlüssel erhalten, wird ein KeyError-Fehler wie folgt ausgelöst:
some_dict = {}
some_dict[ 'colours' ]['favourite'] = "yellow"
# Löst KeyError aus: 'colours'
Aber durch defaultdict können wir diese Situation wie folgt vermeiden:
Sammlungen importieren
json importieren
tree = lambda:collections.defaultdict(tree)
some_dict = tree()
some_dict['colours']['favourite'] = "yellow"
print json.dumps(some_dict)
# Funktioniert einwandfrei, Ausgabe: {"colours": {"favourite": "yellow"}}

2) OrderedDict
OrderedDict kann das Wörterbuch entsprechend der Tastenreihenfolge ausdrucken, wenn wir das Wörterbuch definieren , und ändern Sie den Wert. Die Reihenfolge der Schlüssel wird jedoch nicht geändert, nachdem die Schlüssel gelöscht und erneut eingefügt wurden.
aus Sammlungen importieren OrderedDict

colours = OrderedDict([("Red", 198), ("Green", 170), ("Blue", 160)])
für Schlüssel, Wert in colour.items():
print(key, value)

3) Counter
Verwenden Sie Counter, um die Anzahl der Vorkommen bestimmter Elemente zu zählen, wie zum Beispiel:
aus Sammlungen importieren Counter

Farben = (
('Yasoob', 'Gelb'),
('Ali', 'Blau'),
('Arham', 'Grün'),
( 'Ali', 'Schwarz'),
('Yasoob', 'Rot'),
('Ahmed', 'Silber'),
)

favs = Counter (Name für Name, Farbe in Farben)
print(favs)
# Counter({'Yasoob': 2, 'Ali': 2, 'Arham': 1, 'Ahmed': 1})

4) deque
deque ist eine doppelendige Warteschlange, die am Anfang bzw. Ende wie folgt eingefügt und gelöscht werden kann:
aus Sammlungen importieren 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 kann die maximale Länge der Warteschlange festlegen. Wenn die Anzahl der Elemente die maximale Länge überschreitet, wird die entsprechende Anzahl von Elementen wie folgt aus der entgegengesetzten Richtung der aktuellen Einfügerichtung gelöscht:
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. extensionleft([18])
print(queue_c) # deque([18, 6, 7, 8, 10], maxlen=5)

5) nametuple
tuple ist eine unveränderliche Liste. Die Elemente im Tupel können nicht neu zugewiesen werden. Wir können nur über den Index auf die Elemente im Tupel zugreifen. Das Nametupel kann als unveränderliches Wörterbuch betrachtet werden, und auf die Elemente im Tupel kann über den Namen zugegriffen werden. Zum Beispiel:
Aus Sammlungen importieren benanntes Tupel

Animal = benanntes Tuple('Animal', 'Name Alterstyp')
perry = Animal(name="perry", alter=31, typ=" cat ")

print(perry)
# Ausgabe: Animal(name='perry', age=31, type='cat')

print(perry.name)
# Ausgabe: 'perry'

print(perry[0])
# Ausgabe: 'perry'

print(perry._asdict())
# Ausgabe: OrderedDict ([('name', 'perry'), ('age', 31), ('type', 'cat')])

Objekt-Selbstbeobachtung
1) dir: Liste Alle Methoden des Objekts
2) Typ: Gibt den Typ des Objekts zurück
3) ID: Gibt die ID des Objekts zurück

8 Generator
1) Liste
>>> ; quadriert = [x**2 für x im Bereich(10)]
>>> ; quadriert
[0, 1, 4, 9, 16, 25, 36, 49 , 64, 81]
2) dict
{v: k for k, v in some_dict.items()}
3) set
>>> 2 für x im Bereich (10)🎜>>>> set([0, 1, 4, 81, 64, 9, 16, 49, 25, 36])

9. Ausnahmeverarbeitung

versuchen Sie:

print('Ich bin sicher, dass keine Ausnahme auftreten wird!')
außer Ausnahme:
print('Exception')
else:
# jeder Code, der nur ausgeführt werden soll, wenn beim Versuch keine Ausnahme auftritt,
# aber für den Ausnahmen NICHT abgefangen werden sollen
print('Dies würde nur ausgeführt werden, wenn keine Ausnahme auftritt. Und ein Fehler hier '
'würde NICHT abgefangen werden.')
finally:
print('Dies würde in jedem Fall gedruckt.')

# Ausgabe: Ich bin sicher, dass keine Ausnahme auftreten wird!

# Dies würde nur ausgeführt, wenn keine Ausnahme auftritt.

# Dies würde in jedem Fall gedruckt werden. Die Anweisungen in
else werden vorher ausgeführt.

10. Integrierte Methode

a_list = [[1, 2], [3, 4], [5, 6]]

print(list(itertools.chain.from_iterable(a_list )) )
# Ausgabe: [1, 2, 3, 4, 5, 6]

# oder

print(list(itertools.chain(*a_list)))

# Ausgabe: [1, 2, 3, 4, 5, 6]

class A(object):
def __init__(self, a, b, c, d, e, f):
self.__dict__.update({k: v for k, v in locals().items() if k != 'self'})

for-else-Anweisung
Es gibt zwei normale Möglichkeiten, die for-Anweisung zu beenden: Eine ist, wenn bestimmte Bedingungen erfüllt sind Die nächste Pause besteht darin, aus der Schleife zu springen, und die zweite darin, alle bedingten Schleifen zu beenden. Die else-Anweisung in for-else wird nur ausgeführt, wenn alle Bedingungen beurteilt wurden und die for-Schleife wie folgt normal endet:
for x in range(1, 10, 2):
if x % 2 = = 0:
print "gerade gefunden von %d"%x
break
else:
print "nicht gerade gefunden"
# Ausgabe: nicht gerade gefunden

12 . Kompatibel mit Python 2+ und Python 3+
1) Verwenden Sie das __future__-Modul, um Python 3+-Module in einer Python 2+-Umgebung zu referenzieren
2) Kompatible Modulimportmethoden
versuchen Sie:
import urllib .request als urllib_request # für Python 3
außer ImportError:
import urllib2 als urllib_request # für Python 2

Referenz:

Das obige ist der detaillierte Inhalt vonFassen Sie zusammen, worauf Sie beim Codieren in Python achten müssen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!