Fortgeschrittene Python-Programmierung, acht häufig verwendete Fähigkeiten!

String-Eingabe organisieren

Das Problem der Organisation von Benutzereingaben tritt im Programmierprozess äußerst häufig auf. Oft reicht es aus, Zeichen in Klein- oder Großbuchstaben umzuwandeln, und manchmal können Sie für diese Aufgabe auch das reguläre Ausdrucksmodul „Regex“ verwenden. Wenn das Problem jedoch komplex ist, gibt es möglicherweise einen besseren Weg, es zu lösen:

user_input = "Thisnstring hastsome whitespaces...rn"
character_map = {
ord('n') : ' ',
ord('t') : ' ',
ord('r') : None
}

user_input.translate(character_map)# This string has some whitespaces...

In diesem Beispiel können Sie sehen, dass die Leerzeichen „n“ und „t“ durch ein einzelnes Leerzeichen ersetzt wurden und das „r " wurde gelöscht gelöscht. Dies ist nur ein sehr einfaches Beispiel. Wir können das Paket „unicodedata“ verwenden, um eine große Neuzuordnungstabelle zu generieren und darin „combining()“ zum Generieren und Zuordnen verwenden Wenn Sie eine Slicing-Operation für den Iterator ausführen, wird ein „TypeError“ zurückgegeben, der darauf hinweist, dass das Generatorobjekt keinen Index hat. Wir können dieses Problem jedoch mit einer einfachen Lösung lösen:

import itertools
s = itertools.islice(range(50), 10, 20)# <itertools.islice object at 0x7f70fab88138>
for val in s:
...

Wir können „itertools.islice“ zum Erstellen verwenden 1 Das „islice“-Objekt ist ein Iterator, der die gewünschten Elemente erzeugt. Es ist jedoch zu beachten, dass dieser Vorgang alle Generatorelemente vor dem Slice sowie alle Elemente im „islice“-Objekt verwendet.

Überspringen Sie den Anfang iterierbarer Objekte

Manchmal müssen Sie sich mit einigen Dateien befassen, die mit unerwünschten Zeilen beginnen (z. B. Kommentare). „itertools“ bietet erneut eine einfache Lösung:

string_from_file = """
// Author: ...
// License: ...
//
// Date: ...
Actual content...
"""
import itertools
for line in itertools.dropwhile(lambda line: line.startswith("//"), string_from_file.split("n")):
print(line)

Dieser Code gibt den Inhalt erst nach dem ersten Kommentarteil aus. Diese Methode ist nützlich, wenn wir nur den Anfang des iterierbaren Objekts (in diesem Fall die beginnende Kommentarzeile) verwerfen möchten, aber nicht wissen, wie lang dieser Teil sein soll.

Funktion, die nur Schlüsselwortargumente (kwargs) enthält

Wenn wir die folgende Funktion verwenden, kann es hilfreich sein, eine Funktion zu erstellen, die nur Schlüsselwortargumente als Eingabe erfordert, um eine klarere Funktionsdefinition bereitzustellen:

def test(*, a, b):
pass
test("value for a", "value for b")# TypeError: test() takes 0 positional arguments...
test(a="value", b="value 2")# Works...

Gefällt mir Wie Sie sehen können Durch Hinzufügen eines „*“ vor dem Schlüsselwortparameter kann dieses Problem gelöst werden. Wenn wir einige Parameter vor den Parameter „*“ setzen, handelt es sich offensichtlich um Positionsparameter.

Erstellen Sie Objekte, die die „with“-Anweisung unterstützen

Zum Beispiel wissen wir alle, wie man die „with“-Anweisung verwendet, um eine Datei zu öffnen oder eine Sperre zu erhalten, aber können wir unsere eigenen kontextuellen Ausdrücke implementieren? Ja, wir können „__enter__“ und „__exit__“ verwenden, um das Kontextverwaltungsprotokoll zu implementieren:

class Connection:
def __init__(self):
...
def __enter__(self):
# Initialize connection...
def __exit__(self, type, value, traceback):
# Close connection...
with Connection() as c:
# __enter__() executes
...
# conn.__exit__() executes

Dies ist die häufigste Methode zur Implementierung der Kontextverwaltung in Python, aber es gibt eine einfachere Möglichkeit:

from contextlib import contextmanager
@contextmanager
def tag(name):
print(f"<{name}>")
yield
print(f"</{name}>")
with tag("h1"):
print("This is Title.")

Der obige Absatz Der Code implementiert das Content-Management-Protokoll mithilfe des Manager-Dekorators von contextmanager. Der erste Teil der Tag-Funktion (der Teil vor yield) wird ausgeführt, wenn der with-Block eingegeben wird, dann wird der with-Block ausgeführt und schließlich wird der Rest der Tag-Funktion ausgeführt.

Speicher sparen mit „__slots__“

Wenn Sie jemals ein Programm geschrieben haben, das eine große Anzahl von Instanzen einer bestimmten Klasse erstellt, dann ist Ihnen vielleicht aufgefallen, dass Ihr Programm plötzlich viel Speicher benötigt. Das liegt daran, dass Python Wörterbücher verwendet, um Attribute von Klasseninstanzen darzustellen, was es schnell, aber nicht sehr speichereffizient macht. Normalerweise stellt dies kein ernstes Problem dar. Wenn Ihr Programm jedoch ernsthaft davon betroffen ist, können Sie es auch mit „__slots__“ versuchen:

class Person:
__slots__ = ["first_name", "last_name", "phone"]
def __init__(self, first_name, last_name, phone):
self.first_name = first_name
self.last_name = last_name
self.phone = phone

Wenn wir das Attribut „__slots__“ definieren, verwendet Python kein Wörterbuch zur Darstellung des Attributs, sondern eine kleine feste Größe Array. Dies reduziert den Speicherbedarf pro Instanz erheblich. Die Verwendung von „__slots__“ hat auch einige Nachteile: Wir können keine neuen Attribute deklarieren, wir können nur vorhandene Attribute auf „__slots__“ verwenden. Darüber hinaus können Klassen mit „__slots__“ keine Mehrfachvererbung nutzen.

Begrenzen Sie die „CPU“- und Speichernutzung.

Wenn Sie die Speicher- oder CPU-Auslastung des Programms nicht optimieren, sondern direkt auf eine bestimmte Anzahl begrenzen möchten, verfügt Python auch über eine entsprechende Bibliothek, die dies tun kann:

import signal
import resource
import os
# To Limit CPU time
def time_exceeded(signo, frame):
print("CPU exceeded...")
raise SystemExit(1)
def set_max_runtime(seconds):
# Install the signal handler and set a resource limit
soft, hard = resource.getrlimit(resource.RLIMIT_CPU)
resource.setrlimit(resource.RLIMIT_CPU, (seconds, hard))
signal.signal(signal.SIGXCPU, time_exceeded)
# To limit memory usage
def set_max_memory(size):
soft, hard = resource.getrlimit(resource.RLIMIT_AS)
resource.setrlimit(resource.RLIMIT_AS, (size, hard))

Wir können sehen, dass es im obigen Codeausschnitt Optionen gibt, um sowohl die maximale CPU-Laufzeit als auch das maximale Speichernutzungslimit festzulegen. Wenn wir die Laufzeit einer CPU begrenzen, ermitteln wir zunächst die Soft- und Hard-Limits für diese bestimmte Ressource (RLIMIT_CPU) und legen sie dann mithilfe der über Parameter angegebenen Anzahl von Sekunden und des zuvor abgerufenen Hard-Limits fest. Wenn schließlich die CPU das Limit überschreitet, signalisieren wir dem System, sich zu beenden. In Bezug auf die Speichernutzung rufen wir die Soft- und Hard-Limits erneut ab und legen sie mithilfe von „setrlimit“ mit dem Parameter „size“ und dem zuvor abgerufenen Hard-Limit fest.

Kontrollieren Sie, was importiert werden kann bzw. was nicht.

Einige Sprachen verfügen über einen sehr offensichtlichen Mechanismus zum Exportieren von Mitgliedern (Variablen, Methoden, Schnittstellen). In Golang werden beispielsweise nur Mitglieder exportiert, die mit einem Großbuchstaben beginnen. In Python werden jedoch alle Mitglieder exportiert (es sei denn, wir verwenden „__all__“):

def foo():
pass
def bar():
pass
__all__ = ["bar"]

Im obigen Code wissen wir, dass nur die Funktion „bar“ exportiert wird. Ebenso können wir „__all__“ leer lassen, damit nichts exportiert wird, was beim Import aus diesem Modul zu einem „AttributeError“ führt.

实现比较运算符的简单方法

为一个类实现所有的比较运算符（如 __lt__ , __le__ , __gt__ , __ge__）是很繁琐的。有更简单的方法可以做到这一点吗？这种时候，「functools.total_ordering」就是一个很好的帮手：

from functools import total_ordering
@total_ordering
class Number:
def __init__(self, value):
self.value = value
def __lt__(self, other):
return self.value < other.value
def __eq__(self, other):
return self.value == other.value
print(Number(20) > Number(3))
print(Number(1) < Number(5))
print(Number(15) >= Number(15))
print(Number(10) <= Number(2))

这里的工作原理究竟是怎样的呢？我们用「total_ordering」装饰器简化实现对类实例排序的过程。我们只需要定义「__lt__」和「__eq__」就可以了，它们是实现其余操作所需要的最小的操作集合（这里也体现了装饰器的作用——为我们填补空白）。

结语

并非本文中所有提到的功能在日常的 Python 编程中都是必需或有用的，但是其中某些功能可能会不时派上用场，而且它们也可能简化一些原本就很冗长且令人烦恼的任务。还需指出的是，所有这些功能都是 Python 标准库的一部分。而在我看来，其中一些功能似乎并不像标准库中包含的标准内容，所以当你使用 Python 实现本文提到的某些功能时，请先参阅 Python 的标准库，如果你不能找到想要的功能，可能只是因为你还没有尽力查找（如果真的没有，那它肯定也存在于一些第三方库）。

Das obige ist der detaillierte Inhalt vonFortgeschrittene Python-Programmierung, acht häufig verwendete Fähigkeiten!. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!