Kommentare in Python; Zeichenfolgenformatierung: Formatoperatoren und die Methode format(). §2. Formatierte Ausgabe. print()-Funktion. format()-Methode

Bemerkungen

In diesem Stadium verfügen wir bereits über einen ziemlich umfangreichen Satz an Tools und können ziemlich „verschleierten“ Code schreiben. Nachdem Sie Code in ein paar Dutzend Zeilen geschrieben haben, wird er in ein paar Tagen ziemlich schwer zu lesen sein. Andere Leute werden es noch schwieriger finden, es zu lesen.
Und wenn Sie sich vorstellen, dass in großen Projekten Megabyte Textdateien mit Code werden sie noch schwieriger zu lesen. Diese Situation wird durch Kommentare im Code gespeichert. Diese Kommentare werden von Programmierern hinterlassen, damit sie im Laufe der Zeit das eine oder andere Stück Code klären und einige Aktionen beschreiben können, die in bestimmten Teilen stattfinden. Programmcode. Für Ihre Kollegen und für Sie erleichtert dies die Lesbarkeit des Codes erheblich.

Es gibt zwei Arten von Kommentaren in Python: einzeilig und mehrzeilig. Ein einzeiliger Kommentar beginnt mit dem Zeichen „#“, kann entweder in einer separaten Zeile stehen oder eine Zeile mit einem Code beenden, muss aber ein einzeiliger Kommentar sein, d.h. Sollte nicht auf zwei Zeilen aufgeteilt werden. Es kann eine Codezeile beenden, aber nicht in der Mitte einer Zeile zwischen zwei Codeteilen. Z.B:

i = 0 # Zähler für Schleife

# Die Schleife wird basierend auf der obigen Bedingung ausgeführt

Mehrzeilige Kommentare sind in dreifache Anführungszeichen "" eingeschlossen. Sie können in mehrere Zeilen aufgeteilt werden und lang genug sein. Schreiben Sie mindestens einen Aufsatz. Ein mehrzeiliger Kommentar muss in einer neuen Zeile beginnen und kann in einer anderen fortgesetzt werden Zeilen, zum Beispiel:

"""Durchsuchen Sie die Liste, um das gewünschte Element zu finden

Nach dem Finden unterbrechen wir die Schleife und speichern das Ergebnis in der Variablen x

Wenn das erforderliche Element nicht gefunden wird, informieren wir den Benutzer darüber"""

Bitte beachten Sie, dass ein einzeiliger Kommentar mit der gleichen Einrückung beginnen muss wie der Code des entsprechenden Blocks, sonst kommt es zu einem Trackback. Außerdem muss ein mehrzeiliger Kommentar mit einem Einzug beginnen, der dem Codeblock entspricht. Nachfolgende Zeilen des Kommentars müssen nicht mehr eingerückt werden, der Einzug sollte nur noch vor den kommentaröffnenden Anführungszeichen """ stehen.

Programmieranfänger, und nicht nur Anfänger, schreiben oft offensichtliche Dinge in Kommentare, etwa „Ich habe hier eine Variable x deklariert“. Versuchen Sie, Kommentare zu vermeiden, die die Aktion in menschlicher Sprache duplizieren. Stellen Sie sich vor dem Schreiben eines Kommentars Fragen wie „Wozu dient dieses Code-Snippet?“ „Was ist der Zweck dieses Code-Snippets?“ „Was mache ich mit diesem Code-Snippet?“ „Was ist daran nicht offensichtlich? Schnipsel?" ... Eine Reihe von Fragen wie diese helfen dabei, einen richtigen Kommentar zu erstellen, der wirklich dazu beiträgt, den Code in Zukunft zu pflegen und lesbarer zu machen.

Zeichenfolgenformatierungsoperatoren

Unter dem Ausdruck „Formatierung eines Strings“ verstehen wir nun die Erweiterung der Werte von Variablen in einem String, d.h. Wenn eine Zeile benötigt wird, fügen Sie die Werte einiger Variablen ein. Bisher haben wir dies getan, indem wir "+" zum Verbinden von Zeichenfolgen und "," verwendet haben, um numerische Ausdrücke nach Zeichenfolgen zu schreiben. Es sah zumindest hässlich aus.

>>> a = "Hallo"

>>>b="lieb"

>>> a + " " + b

Es gibt 2 reguläre Möglichkeiten, die Werte von Variablen in einer Zeichenfolge zu erweitern. Jetzt werden wir darüber sprechen, wie die Formatierung mit Formatoperatoren erfolgt. Diese Methode ist älter, veraltet, am wenigsten bequem und unerwünscht in der Verwendung, wird aber häufig in älterem Code verwendet.

Betrachten wir die folgende Option:

>>> a = "Wasja"

>>> drucke "Hallo %s" % a

Hallo Wasja

Was ist los? Alles ist ganz einfach. Der %s-Operator in unserem String wird durch die Variable rechts vom %-Zeichen nach unserem String ersetzt.

Schauen wir uns ein anderes Beispiel an:

>>>name="Wasja"

>>> Nachname = "Pupkin"

>>>Alter = 25

>>> print "Vorname %s, Nachname %s, Alter %d" % (Name,Nachname,Alter)

Vorname Vasya, Nachname Pupkin, Alter 25

Beachten Sie zunächst, dass wir, wenn es mehr als eine Variable gibt, sie in einem Tupel () übergeben. Sie haben vielleicht auch bemerkt, dass ich die Stringwerte der Variablen mit dem %s-Operator übergeben habe und die Variable, die sich auf die Zahl bezieht, mit dem %d-Operator. Es funktioniert nur so. Jeder Operator kann einen Wert eines bestimmten Typs erweitern: %s ist ein String, %d ist eine Zahl und so weiter. Eine detailliertere Liste von Operatoren wird unten angegeben.

Die erste Frage, die sich von selbst stellt, lautet: "Wie können wir den Wert einer Variablen mehrmals in einer Zeile anzeigen?". Die Antwort liegt auf der Hand, wir müssen diese Variable im Tupel so oft und in der Reihenfolge übergeben, in der wir die Werte dieser Variablen in unserem String erweitern. Es ist ungeschickt und unbequem. Wir müssen die Variablen immer in einer strengen Reihenfolge schreiben, die der Erweiterung ihrer Operatoren in der Zeile entspricht, und sie gegebenenfalls sogar wiederholen.

Liste der Formatoperatoren:

"%d", "%i", "%u"

Dezimalzahl.

Zahl im Oktalsystem.

Zahl in hexadezimaler Schreibweise (Kleinbuchstaben).

Zahl in hexadezimaler Schreibweise (Großbuchstaben).

Fließkommazahl mit Exponent (Kleinbuchstaben-Exponent).

Fließkommazahl mit Exponent (Exponent in Großbuchstaben).

Fließkommazahl (normales Format).

Fließkommazahl. mit dem Exponenten (Kleinbuchstaben-Exponent), wenn er kleiner als -4 oder Genauigkeit ist, ansonsten normales Format.

Fließkommazahl. mit Exponent (Exponent in Großbuchstaben), wenn kleiner als -4 oder Genauigkeit, sonst normales Format.

Zeichen (Zeichenfolge aus einem Zeichen oder einer Zahl - Zeichencode).

Zeichenfolge (Python-Literal).

Eine Zeichenfolge (wie sie normalerweise vom Benutzer wahrgenommen wird).

Formatoperatoren (optional)

Hier werde ich kurz demonstrieren Zusatzfunktionen Formatoperatoren.

Konvertierungsspezifizierer werden in der folgenden Reihenfolge geschrieben:

2. Schlüssel (optional), bestimmt, welches Argument des Werts ersetzt wird.

3. Konvertierungsflags.

4. Minimale Feldbreite. Wenn *, wird der Wert aus dem Tupel genommen.

5. Genauigkeit, beginnt mit ".", dann die gewünschte Genauigkeit.

6. Längenmodifikator (optional).

7. Typ (siehe Tabelle oben).

>>> print ("%(language)s hat %(number)03d Anführungszeichen." % ("language": "Python", "number": 2))

Python hat 002-Zitattypen.

Konvertierungsflags:

Der Wert verwendet die alternative Form.

Freier Speicherplatz wird mit Nullen aufgefüllt.

Der freie Platz wird rechts mit Leerzeichen aufgefüllt.

Der freie Platz wird links mit Leerzeichen aufgefüllt.

>>> "%.2s" % "Hallo!"

>>> "%.*s" % (2, "Hallo!")

>>> "%-10d" % 25

>>> "%+10f" % 25

>>> "%+10s" % "Hallo"

Eine nähere Analyse dieser Merkmale macht aufgrund ihrer seltenen Verwendung keinen Sinn.

format() String-Formatierungsmethode

Die Formatierungsoperatoren wurden durch die String-Methode ersetzt Format(). Diese Methode ist viel flexibler, bequemer und vielseitiger in der Anwendung. Schauen wir uns seine Verwendung zum Auspacken der Werte von Variablen in einer Zeichenfolge an.

>>>name="Wasja"

>>> Nachname = "Pupkin"

>>>Alter = 25

>>> print "() (), Alter ()".format(Name,Nachname,Alter)

Vasya Pupkin, 25 Jahre

Hier ist alles ganz offensichtlich. Die geschweiften Klammern () bestimmen, wo die Variablen im String erweitert werden, und an die Methode format() übergeben wir die Variablen, die erweitert werden müssen. Gegenüber den Formatierungsoperatoren hat sich auf den ersten Blick nichts geändert. Wir haben immer noch keine Kontrolle über unseren Einsatz. Der einzige Unterschied besteht darin, dass wir uns nicht mehr eine Reihe von Operatoren merken müssen, um Werte auszupacken verschiedene Typen. Nichts, das ist erst der Anfang. Lassen Sie uns die Funktionalität sequenziell erhöhen. Betrachten wir die folgende Option:

>>>name="Wasja"

>>> Nachname = "Pupkin"

>>>Alter = 25

>>> print "(0) (1), Alter (2)". Format (Name, Nachname, Alter)

Vasya Pupkin, 25 Jahre

Es hat sich nichts geändert, aber einige Zahlen wurden zu unseren geschweiften Klammern hinzugefügt. Schauen wir uns das folgende Beispiel an:

>>> print "(1) (0), Alter (2)". Format (Name, Nachname, Alter)

Pupkin Vasya, 25 Jahre alt

Der Ausgabestring hat sich geändert, wir haben die Werte vertauscht. Sie haben vielleicht bemerkt, dass wir die Variablen, die wir an die Methode übergeben haben, nicht vertauschen mussten, wir haben nur die Zahlen in geschweiften Klammern () vertauscht. Diese Zahlen sind eine Art Index jener Variablen, die wir in unserer Linie erweitern wollen. Im letzten Beispiel haben wir die Variable bei Index 1 erweitert, dann 0 und 2, d.h. Die zweite, erste und dritte Variable, die an die Methode übergeben werden. Das bedeutet, dass wir durch Angabe der Indizes der Variablen, die an die Methode übergeben wurden, diese in der gewünschten Reihenfolge erweitern können. Außerdem können wir den Wert einer Variablen mehrmals in einer Zeile darstellen, indem wir deren Index mehrfach in geschweiften Klammern angeben.

>>> print "(1) (1), Alter (2)". Format (Name, Nachname, Alter)

Pupkin Pupkin im Alter von 25 Jahren

Stimmen Sie zu, dies ist im Vergleich zu Formatierungsoperatoren bereits eine viel flexiblere und bequemere Möglichkeit, eine Zeichenfolge zu formatieren. Aber die Flexibilität dieser Methode zum Erweitern der Werte von Variablen endet hier nicht. Werfen wir einen Blick auf die Option benannte Argumente.

>>> a = "Wasja"

>>> b="pupkin"

>>> print "(Name) (Nachname), Alter (Alter)".format(Alter=c,Name=a,Nachname=b)

Vasya Pupkin, 25 Jahre

Hier ist es noch interessanter. Die benötigten Daten befanden sich unter den bedeutungslosen Variablen a, b und c. Als wir diese Variablen an unsere Methode übergaben, gaben wir ihnen aussagekräftige Namen wie (Name=Variable) und verwendeten diese Namen dann in unseren geschweiften Klammern ().

An die Formatmethode können wir eine Liste von Werten übergeben und sie in unserem String erweitern. Es passiert so:

>>> l = ["Wasja", "Pupkin", 25]

["Wasja", "Pupkin", 25]

>>> print "(0) (1), Alter (2)". format(*l)

Vasya Pupkin, 25 Jahre

Hier ist alles mehr als offensichtlich. Wir haben eine Liste übergeben und per Index auf ihre Elemente zugegriffen, aber beim Übergeben der Liste haben wir der Variablen das Zeichen „*“ vorangestellt, das der format()-Methode explizit mitteilte, dass wir die Elemente dieser Liste erweitern würden. Was passiert, wenn wir das "*" vor dem Listenargument weglassen?

>>> print "(0) (1), Alter (2)". format(l)

Traceback (letzter Aufruf zuletzt):

Datei " ", Zeile 1, in

IndexError: Tupelindex außerhalb des zulässigen Bereichs

Die Methode wusste nicht, dass wir eine Liste übergeben hatten und versuchte, die üblichen Argumente an den Indizes 1 und 2 zu suchen, auf die wir im String zugegriffen haben.

Auf ähnliche Weise können wir auch ein Wörterbuch an die Methode format() übergeben.

>>> db = ("name":"Vasya", "lastname":"Pupkin", "age":25)

("Nachname": "Pupkin", "Alter": 25, "Name": "Vasya")

>>> print "(Name) (Nachname), Alter (Alter)".format(**db)

Vasya Pupkin, 25 Jahre

Dies ist dem Übergeben von benannten Argumenten sehr ähnlich, mit dem einzigen Unterschied, dass wir ein Wörterbuch an unsere Methode übergeben haben. Wenn wir vor der Übertragung der Liste ein Sternchen "*" angegeben haben, dann setzen wir vor der Übertragung des Wörterbuchs zwei Sternchen "**" vor das Argument in der Methode format () und verweisen in geschweiften Klammern der Zeichenfolge auf die Schlüssel des übertragenen Wörterbuchs, um ihre Werte zu erweitern.

Wir haben alle Optionen zum Erweitern von Variablen in einem String mit der Methode format() berücksichtigt. In Zukunft empfehle ich dringend, diese Methode anstelle von Formatoperatoren zu verwenden, as Diese Methode ist neuer, flexibler und offizielle Quellen raten uns, bei dieser speziellen Methode zu bleiben.

format()-Methode (optional)

Als Nächstes werde ich zusätzliche Optionen für die Inline-Methode format() bereitstellen. Ausführlichere Informationen zu diese Methode, können Sie im Artikel über Habré oder in der offiziellen Python-Dokumentation nachsehen.

Aufmerksamkeit! Das Folgende ist ein Fragment eines Artikels über die Methode format()

Fangen wir wieder ganz einfach an: Wenn Sie einen String einer bestimmten Länge ausgeben müssen, fügen Sie nach dem Variablennamen einen Doppelpunkt (:) und dann die Anzahl der Zeichen hinzu. Um also meinen Namen zu drucken und ihn mit Leerzeichen bis zu zehn Zeichen aufzufüllen, würde ich Folgendes tun:

>>> "Ihr Name ist (Name:10)".format(name="Reuven")

"Ihr Name ist Reuven"

(Beachten Sie, dass die Zeichenfolge nach dem Namen mit Leerzeichen aufgefüllt wird.)

Wenn Sie die Ausrichtung auf der rechten Seite des Blocks festlegen müssen, verwenden Sie das Zeichen > zwischen: und der Zahl:

>>> "Ihr Name ist (name:>10)".format(name="Reuven")

"Ihr Name ist Reuven"

Und ja, Sie können mit dem Vorzeichen explizit angeben, dass ich eine Linksbündigkeit haben möchte<

Wenn Sie den Wert in der Mitte des Blocks anzeigen müssen, dann statt< и >das ^-Symbol wird verwendet:

>>> "Ihr Name ist (Name:*^10)".format(name="Reuven")

"Ihr Name ist **Reuven**"

Der Text ist mehr oder weniger klar, aber was ist mit den Zahlen? Für mich persönlich war es schwierig, mir vorzustellen, wie es funktionieren würde, aber es stellte sich heraus, dass alles ganz einfach war. Zum einfache Ausgabe zahlen, verwenden wir eine string-ähnliche Syntax:

>>> "Der Preis beträgt $(Zahl).".format(Zahl=123)

Bisher haben wir zwei Ausgabemethoden verwendet: das interaktive Drucken der Werte von Ausdrücken und die Verwendung der print-Anweisung (die dritte Methode ist die Methode write() von Dateiobjekten).

Oft besteht der Wunsch, mehr Kontrolle über die Ausgabeformatierung zu haben, als nur durch Leerzeichen getrennte Werte anzuzeigen. Natürlich können Sie die Saiten selbst manipulieren: Mit den Slice- und Join-Operationen können Sie jede erdenkliche Anordnung erstellen. Strings haben Methoden, um sie mit Leerzeichen auf die gewünschte Spaltenbreite aufzufüllen 1 . Eine andere Möglichkeit besteht darin, den %-Operator mit einer Zeichenfolge als linkes Argument zu verwenden. Der %-Operator interpretiert die Zeichenfolge auf der rechten Seite als eine Formatzeichenfolge im Stil von C sprintf(), die auf das rechte Argument angewendet wird, und gibt eine Zeichenfolge mit dem Ergebnis des Formats zurück.

Natürlich bleibt noch eine Frage: Wie erhält man eine String-Darstellung für Werte unterschiedlichen Typs? Glücklicherweise bietet Python die Möglichkeit, einen Wert eines beliebigen Typs in einen String umzuwandeln: mit der Funktion str(). Tatsächlich bietet die Sprache zwei Funktionen zum Abrufen einer Zeichenfolgendarstellung - repr() (derselbe Effekt kann einfach dadurch erzielt werden, dass der Ausdruck in Anführungszeichen gesetzt wird: `expr` ) und str() . Die erste Methode wird beispielsweise vom Interpreter verwendet, um die Werte von Ausdrücken im interaktiven Modus anzuzeigen, die zweite, um Argumente mithilfe der print-Anweisung anzuzeigen. Die Funktion str() gibt nach Möglichkeit die für die Ausgabe am besten geeignete Darstellung zurück, während die Funktion repr() eine interaktive Ausdruckseingabe zurückgibt. Hier sind einige Beispiele:

>>> x = 10 * 3,14

Die Zahl 31,4 kann nicht exakt binär dargestellt werden, also:

>>>x
31.400000000000002

Die Funktion str() gibt die Zahl jedoch mit angemessener Genauigkeit aus:

>>> y=200*200
>>> s = "Der Wert von x ist " + str(x) + \
... ", der Wert von y ist " + str(y) + "..."
>>>Drucke
Der x-Wert ist 31,4, der y-Wert ist 40000...

Lange Ganzzahlen werden in Python mit einem „L“-Suffix geschrieben. Seit Version 1.6 gibt die Funktion str() es nicht aus:

>>> repr(1000L)
"1000 Liter"
>>>str(1000L)
"1000"

Eine String-Darstellung kann auch für andere Typen erhalten werden:

>>>p=
>>> ps = repr(p)
>>>ps
""
>>> `x, y, ("Spam", "Eier")`
"(31.400000000000002, 40000, ("Spam", "Eier"))"

Die Funktion repr() (oder `` ) fügt Anführungszeichen hinzu und schreibt Sonderzeichen mithilfe von Escape-Sequenzen:

>>> hallo = "Hallo, Welt\n"
>>> Hallo drucken
Hallo Welt

>>> hallo = `hallo`
>>> Hallo drucken
"Hallo Welt\n"

Wir leiten eine Tabelle aus Quadraten und Kuben auf die beiden beschriebenen Arten ab:

>>> für x im Bereich (1, 11):
... drucke str(x).rjust(2), str(x*x).rjust(3),
... # Beachten Sie das nachgestellte Komma
... print str(x*x*x).rjust(4)
...
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000

>>> für x im Bereich (1,11):
... drucke "%2d %3d %4d" % (x, x*x, x*x*x)
...
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000

(Beachten Sie, dass durch die print-Anweisung ein Leerzeichen zwischen den Spalten hinzugefügt wurde.)

Dieses Beispiel demonstriert die Verwendung der String-Methode rjust(), die einen String in einem Feld der angegebenen Breite rechtsbündig ausrichtet und ihn links mit Leerzeichen auffüllt. Die Methoden ljust() und center() funktionieren ähnlich. Sie geben nichts aus, sie geben nur einen Zeilenumbruch zurück. Wenn die Eingabezeichenfolge zu lang ist, wird sie nicht abgeschnitten, sondern unverändert zurückgegeben: Es ist normalerweise besser, das Spaltenlayout zu vermasseln, als einen falschen Wert auszugeben. (Wenn Sie es wirklich schneiden möchten, verwenden Sie die Slice-Operation: "s.ljust(n)" .)

Nützlich kann auch die im String-Modul definierte Funktion zfill() sein, die einen Zahlenstring links mit Nullen auffüllt und dabei Plus- und Minuszeichen korrekt behandelt:

>>> Zeichenkette importieren
>>> string.zfill("12", 5)
"00012"
>>> string.zfill("-3.14", 7)
"-003.14"
>>> string.zfill("3.14159265359", 5)
"3.14159265359"

Die Verwendung des Operators % sieht ungefähr so aus:

>>> Mathematik importieren
>>> print "PI-Wert ist ungefähr gleich %5,3f." %\
... math.pi
Der PI-Wert ist ungefähr gleich 3,142.

Sollen mehrere Werte in einem String dargestellt werden, wird als rechter Operand ein Tupel verwendet:

>>> table = ("Sjoerd": 4127, "Jack" : 4098, "Dcab" : 7678)
>>> für Name, Telefon in table.items():
... print "%-10s ==> %10d" % (Name, Telefon)
...
DCab ==> 7678
Jack ==> 4098
Sjoerd ==> 4127

Die meisten Formate funktionieren genauso wie in C. Wenn die Argumenttypen jedoch nicht mit dem Format übereinstimmen, wandelt der Interpreter sie in den erforderlichen Typ um (z () eingebaute Funktion) oder, falls dies nicht möglich ist, löst Ausnahme 2 aus. Sie können * verwenden, um die Feldbreite oder -genauigkeit als separaten Parameter zu übergeben.

Beachten Sie, dass wenn das richtige Argument ein Tupel ist, it immer als Argumentliste betrachtet:

>>> def f(x):
... print "Der Wert "%s", der an die Funktion übergeben wurde" % x
...
>>> f(1)

>>> f()

>>> # wird nicht wie erwartet interpretiert
...f((1,))
Der Funktion wurde der Wert "1" übergeben
>>> # Fehler
...f((1, 2))
Traceback (letzter Aufruf zuletzt):
Datei" “, Zeile 2, ein
Datei" “, Zeile 2, in f
TypeError: Nicht alle Argumente wurden während der Zeichenfolgenformatierung konvertiert

IN dieser Fall es wäre sicherer, als rechten Operanden ein Tupel zu verwenden, das aus einem Element besteht:

>>> def f(x):
... print "Der an die Funktion übergebene Wert ist '%s'" % (x,)
...
>>> # Jetzt ist alles korrekt
...f((1,))
Funktion hat den Wert "(1,)" übergeben
>>> f((1, 2))
Funktion hat Wert "(1, 2)" übergeben
>>> f(1)
Der Funktion wurde der Wert "1" übergeben
>>> f()
Funktion hat Wert "" übergeben

Bei langen Formatzeichenfolgen möchten Sie möglicherweise auf Variablen mit Namen statt auf ihre Position verweisen. Dies kann unter Verwendung der erweiterten Notation als %(name)format erfolgen, zum Beispiel:

>>> table = ("Sjoerd": 4127, "Jack": 4098, "Dcab": 8637678)
>>> print "Jack: %(Jack)d; Sjoerd: %(Sjoerd)d; Dcab: %(Dcab)d" % Tabelle
Buchse: 4098; Sjörd: 4127; Dcab: 8637678

Diese Notation ist besonders nützlich, wenn sie mit der integrierten Funktion vars() kombiniert wird, die ein Wörterbuch mit Variablen im aktuellen Gültigkeitsbereich zurückgibt.

Übersetzung

Ich mache Habra-Leser und Python-Fans auf die Übersetzung eines ziemlich umfangreichen Artikels über String-Formatierung aufmerksam. Die Geschichte wird wahr sein und darauf hindeuten, dass Konservative manchmal etwas Neues in Betracht ziehen sollten, auch wenn die Gewohnheit sich hartnäckig widersetzt.

In Erwartung der Neugier der Leser, die dazu neigen, Fragen abseits des Gesprächsthemas zu stellen, werde ich sagen, dass das Bild indirekt mit Python verwandt ist, wenn auch nicht das angenehmste. Ich schlage vor, als Hausaufgabe herauszufinden, warum.

Ich warte auf Kommentare zu Fehlern im Design und Tippfehlern in einem persönlichen - traditionellen habraplyushki von mir.

Ich schreibe seit vielen Jahren in Python. Aber ganz am Anfang dieser Reise war ich daran interessiert zu lernen, wie man Strings im Perl-Stil formatiert. Ich möchte Sie daran erinnern, dass Perl (und viele Interpreter Befehlszeile unter Unix) unterstützen zwei Arten von String-Literalen - with Einzelzitate(wenn die Zeichenfolge unverändert angezeigt wird) und verdoppelt, wo ihre Werte die Variablen ersetzen. In Perl können Sie zum Beispiel so etwas schreiben wie:

$name = "Reuven"; print "Hallo, $name\n";
Und das Programm wird dementsprechend "Hello, Reuven" schreiben.

Zeichenfolgenliterale in Python hängen nicht von der Art der Anführungszeichen ab und die darin enthaltenen Variablen werden niemals auf ihre Werte erweitert. Um dies zu erreichen, wurde traditionell der %-Operator für Zeichenfolgen verwendet. Dabei schaut der Operator auf den String links davon und zählt, wie viele Werte durch die Werte der entsprechenden Variablen rechts davon ersetzt werden müssen. Das Ergebnis der Operation ist eine neue Zeile mit den Werten der Variablen, die anstelle der Platzhalter eingefügt werden. Zum Beispiel:

>>> name = "Reuven" >>> "Hallo, %s" % name "Hallo, Reuven"
Dieser Python-Code funktioniert einwandfrei und druckt einen personalisierten Gruß aus. Trotz meiner langjährigen Praxis mit Python war ich also mit der Verwendung dieser Syntax recht zufrieden. Ja, es ist nicht sehr schön und nein, ich habe nie an einen Berg von printf-Modifikatoren gedacht, die die Formatierung beeinflussen. Ich meine, ich habe immer den Modifikator "s" verwendet (Ausgabe als Zeichenfolge) und es hat mir gereicht, dass Python die Argumente implizit in die Zeichenfolge umwandelt.

Aber im Moment ist die %-Syntax veraltet oder zumindest veraltet. Die python-dev-Mailingliste gibt an, dass es bis mindestens 2022 im 2.x-Zweig leben wird, aber es wird nichts über den 3.x-Zweig gesagt, sodass die Unterstützung für diese Syntax bald entfernt wird und es unerwünscht ist, sie zu verwenden. Sie wurde durch die Methode str.format ersetzt.

In meinen Python-Tutorials habe ich immer str.format erwähnt, aber in konkrete Beispiele meistens stützte sich alles auf %. Ich habe die Schüler sogar ermutigt, % zu verwenden, da ich es persönlich viel einfacher fand.

Aber das hartnäckige Gefühl, etwas falsch zu machen und meine Schüler vielleicht sogar in die Irre zu führen, veranlasste mich, das Str.-Format genauer zu studieren. Im Laufe der Recherche bin ich zu folgenden Schlussfolgerungen gekommen: 1) Es ist nicht komplizierter als % und in einigen Anwendungen sogar einfacher; 2) Ich habe die Funktionen von str.format noch nie voll ausgeschöpft, und sie sind trotz der Zeit, die man braucht, um sie zu lernen, sehr praktisch.

Beginnen wir mit dem Einfachsten. Sagen wir jemandem „Guten Morgen“ und sprechen ihn mit seinem Vor- und Nachnamen an, vorausgesetzt, er ist in den Variablen „first“ und „last“ gespeichert. Auf die alte Weise würden wir dies tun:

>>> first = "Reuven" >>> last = "Lerner" >>> "Guten Morgen, %s %s" % (first, last) "Guten Morgen, Reuven Lerner"
Sogar in diesem Beispiel stoßen wir auf eines der %-Syntaxprobleme – wir haben jetzt zwei Variablen, und um beide zu verwenden, müssen wir ein Tupel daraus machen. Aus Python-Sicht ist das logisch, aber ich versichere Ihnen, dass viele Studenten davon sehr überrascht sind.

Wie würde dieses Beispiel im Fall von str.format aussehen? Ziemlich ähnlich:

>>> "Guten Morgen, () ()".format(first, last) "Guten Morgen, Reuven Lerner"
Bitte beachten Sie, dass wir das Prinzip leicht verändert haben. Jetzt ist es nicht binärer Operator oben genannten Zeichenfolgen und eine Zeichenfolgenobjektmethode, die eine Reihe von Parametern akzeptiert. Das ist logisch und konsequenter. Für dieselben Schüler sah der %-Operator in meinen Beispielen wie eine Ergänzung zu print aus, nicht wie eine Zeichenfolgenoperation. Die „.format“-Notation nach der Zeichenfolge macht deutlicher, dass es sich um eine für diese Zeichenfolge spezifische Methode handelt.

Wie Sie wahrscheinlich bereits wissen, weisen Vorkommen von „() ()“ in einem String str.format an, zwei Parameter zu übernehmen, deren Werte in der Reihenfolge, in der sie an die Methode übergeben werden, in den String eingefügt werden. Es gibt zwei Argumente, daher sollte () zweimal in der Zeichenfolge vorkommen. Dies ist etwas schwieriger zu verstehen, da geschweifte Klammern in Python auf Wörterbücher hinweisen und leere Klammern nicht sehr schön aussehen. Aber das ist okay, ich kann damit leben und habe es ganz locker hingenommen.

Der Punkt, an dem str.format den ersten Vorteil gegenüber % zeigt, ist, wenn Parameter in verwendet werden müssen umgekehrte Reihenfolge. Tatsächlich gibt es mit %s überhaupt keine Möglichkeit, dies zu erreichen. Es ist auch nicht möglich, den Wert derselben Variablen mehr als einmal zu verwenden. Bei Verwendung von str.format können wir die Ersetzungsreihenfolge einfach ändern:

>>> "Guten Morgen, (1) (0)".format(first, last) "Guten Morgen, Lerner Reuven"
Bitte beachten Sie, dass bei Verwendung von leeren Klammern „() ()“ die Ersetzung in derselben Reihenfolge erfolgen würde, in der die Parameter an die Methode übergeben werden. Man kann sich die Parameter als eine von Null indizierte Folge vorstellen, und wenn ich die Reihenfolge ändern möchte, dann trage ich einfach die nötigen Indizes dieser Folge in geschweiften Klammern ein. Unser allererstes Beispiel mit str.format kann so geschrieben werden:

>>> "Guten Morgen, (0) (1)".format(first, last) "Guten Morgen, Reuven Lerner"
Beachten Sie, dass wir uns durch die explizite Angabe von Indizes nicht mehr auf die automatische Indizierung verlassen können.

Natürlich können Sie auch eine Sequenz aus einer Liste mit dem *-Operator verwenden:

>>> names = ("Reuven", "Lerner") >>> "Guten Morgen, () ()".format(*names) "Guten Morgen, Reuven Lerner"
Sie können auch benannte Argumente verwenden:

>>> "Guten Morgen, (erster) (letzter)".format(first="Reuven", last="Lerner") "Guten Morgen, Reuven Lerner"
Diese Möglichkeit gefällt mir besonders gut. Benannte Parameter sind expliziter (falls vorhanden gute namen), und das Anwenden von (first) und (last) ist recht lesbar - insbesondere im Vergleich zu %(first)s, das mit dem %-Operator benötigt wird

Benannte Parameter können auch mithilfe des **-Operators aus einem Wörterbuch erweitert werden:

>>> person = ("first":"Reuven", "last":"Lerner") >>> "Guten Morgen, (erster) (letzter)".format(**person) "Guten Morgen, Reuven Lerner"
All dies habe ich meinen Schülern beschrieben und war ziemlich überrascht, wie vertraut sie mit dieser Syntax sind. Ja, und es wurde angenehmer zu arbeiten.

Es sollte erwähnt werden, dass benannte und positionelle Argumente technisch zusammen verwendet werden können. Aber es ist besser, dies nicht zu tun:

>>> person = ("first":"Reuven", "last":"Lerner") >>> "Gut (0), (first) (last)".format("morning", **person) " Guten Morgen Reuven Lerner"

Ich warnte.

Was in str.format fehlen könnte, ist ... ähm ... Formatierung. Die schlechte Nachricht ist, dass str.format völlig andere Regeln für die Formatierung der Ausgabe hat. Die gute Nachricht ist, dass diese Regeln ziemlich einfach zu erlernen und zu verstehen sind.

>>> "Ihr Name ist (name:10)".format(name="Reuven") "Ihr Name ist Reuven "
(Beachten Sie, dass die Zeichenfolge nach dem Namen mit Leerzeichen aufgefüllt wird.)

Wenn Sie die Ausrichtung auf der rechten Seite des Blocks festlegen müssen, verwenden Sie das Zeichen > zwischen: und der Zahl:

>>> "Ihr Name ist (name:>10)".format(name="Reuven") "Ihr Name ist Reuven"
Und ja, Sie können mit dem Vorzeichen explizit angeben, dass ich eine Linksbündigkeit haben möchte<
Wenn Sie den Wert in der Mitte des Blocks anzeigen müssen, dann statt< и >das ^-Symbol wird verwendet:

>>> "Ihr Name ist (name:*^10)".format(name="Reuven") "Ihr Name ist **Reuven**"
Der Text ist mehr oder weniger klar, aber was ist mit den Zahlen? Für mich persönlich war es schwierig, mir vorzustellen, wie es funktionieren würde, aber es stellte sich heraus, dass alles ganz einfach war. Für eine einfache Ausgabe von Zahlen verwenden wir eine String-ähnliche Syntax:

>>> "Der Preis beträgt $(number).".format(number=123) "Der Preis beträgt $123."
Aber für Zahlen gilt es große Menge Modifikatoren als für Zeichenfolgen. Um beispielsweise eine Zahl in binärer Form anzuzeigen, fügen Sie den Modifikator "b" hinzu, wenn sie hexadezimal ist, den Modifikator "x":

>>> "Der Preis beträgt $(number:b).".format(number=5) "Der Preis beträgt $101." >>> "Der Preis beträgt $(number:x).".format(number=123) "Der Preis beträgt $7b."
Natürlich kann die Zahleneingabe mit führenden Nullen ergänzt werden:

>>> "Ihr Anruf ist uns wichtig. Sie sind die Rufnummer #(Nummer:05).".format(number=123) "Ihr Anruf ist uns wichtig. Sie sind die Rufnummer #00123."
Beachten Sie, dass ausführbarer Python-Code nicht innerhalb von () verwendet werden kann - stattdessen wird eine einfache Mikrosprache angeboten, getrennt und verschieden von Python als Ganzes. Es gibt auch kleinere Ausnahmen. Erstens können Sie die Werte von Attributen/Eigenschaften durch einen Punkt erhalten und zweitens den Wert eines Objekts per Index mit .

Zum Beispiel:

>>> class Foo(object): def __init__(self): self.x = 100 >>> f = Foo() >>> "Deine Nummer ist (ox)".format(o=f) "Deine Nummer ist 100"n
Wir haben das Attribut "x" des Objekts "f" erhalten. Dieses Objekt ist unter dem Namen "o" innerhalb der Zeichenfolge verfügbar. Sie können ein Attribut abrufen, aber nicht ausführen:

>>> "Ihr Name ist (name.upper())".format(name="Reuven") AttributeError: "str" Objekt hat kein Attribut "upper()"
Ich habe "name.upper()" ausprobiert, vorausgesetzt, die entsprechende Methode würde aufgerufen werden, aber Python erlaubt nicht, dass Code an dieser Stelle ausgeführt wird, und behandelt "upper()" als Attribut zusammen mit Klammern. Ohne Klammern erhalten Sie nur eine Zeichenfolgendarstellung der Funktion/Methode:

>>> "Ihr Name ist (name.upper)".format(name="Reuven") "Ihr Name ist "
Mit eckigen Klammern können Sie ein Element eines iterierbaren Objekts (Liste, String) per Index nehmen. Slice-Operationen werden jedoch nicht unterstützt:

>>> "Ihre Lieblingszahl ist (n).".format(n=Zahlen) "Ihre Lieblingszahl ist 3."
Aber:

>>> "Deine Lieblingszahlen sind (n).".format(n=Zahlen) ValueError: Fehlendes "]" im Formatstring
Es kann auch verwendet werden, um Einträge im Wörterbuch nach Namen zu erhalten, aber der Name wird ohne Anführungszeichen eingegeben:

>>> person = ("first":"Reuven", "last":"Lerner") >>> "Ihr Name ist (p).".format(p=person) "You name is Reuven."
Beim Versuch, Anführungszeichen zu verwenden, erhalten wir eine Ausnahme ...

>>> "Ihr Name ist (p["first"]).".format(p=person) KeyError: ""first""
Nicht alle Verwendungen von str.format sind hier aufgeführt – tatsächlich hat jeder Typ eine Formatierungsregelspezifikation. Beispielsweise ist die Genauigkeitsoption für Gleitkommazahlen für Zeichenfolgen nicht verfügbar.

Sie können Ihren Klassenobjekten sogar benutzerdefinierte Formatierungsregeln hinzufügen, sodass sie einen bestimmten Rendering-Stil und Modifikatoren haben, um ihn anzupassen.

Wenn Sie dieses Thema genauer untersuchen möchten, sollten Sie mit PEP 3101 beginnen, das str.format beschreibt. Empfehlen kann ich auch den Vortrag von Eric Smith mit einer recht guten Zusammenfassung zu diesem Thema. Es gibt auch gute Beispiele Informationen zum Wechseln von % zu str.format in der Python-Dokumentation

Ich hoffe, es hat euch gefallen!

Ich habe kürzlich herausgefunden, dass der Blog von Zeit zu Zeit für "Was bedeutet %s in Python" gefunden wird. Ich erinnere mich an mich selbst - als ich anfing, Python zu lernen, wollte ich schnelle und verständliche Antworten (sie sagen: "Täuschen Sie nicht Ihren Kopf, zeigen Sie mit dem Finger"). Für Ungeduldige dieser Artikel.

Inhaltsverzeichnis

Zu Beginn ein paar Beispiele

Zeichenfolgenformatierung:
>>> name = "Vasya" >>> print "Mein Name ist %s" % (name) Mein Name ist Vasya Festlegen der Größe der Felder (vor "Vasya" sind fünf Leerzeichen, also insgesamt zehn Zeichen): > >> print "Mein Name ist %10s. Das ist mein Name." % (Name) Mein Name ist Vasya. Das ist mein Name. Dasselbe, aber linksbündig: >>> print "Mein Name ist %-10s. Das ist mein Name." % (Name) Mein Name ist Vasya . Das ist mein Name. Wenn es nützlich sein könnte: >>> Getränke = ("Long Island": 3, "Bloody Mary": 2, "Margarita":4) >>> print "%-15s%-5s" % ("Name", "Menge") Name Menge >>> für k,v in drinks.items(): ... print "%-15s%-3s" % (k, v) ... Bloody Mary 2 Long Island 3 Margarita 4 Wenn Sie den ganzzahligen Teil einer Zahl ausgeben müssen:
>>> num = 12.34 >>> print "%d" % (num) 12 Verwechselt:
>>> Alter = 25 >>> print "Mein Name ist %s. Ich bin %d." % (Name, Alter) Mein Name ist Vasya. Ich bin 25.

Nun kurz, wie der %-Operator funktioniert

Der Formatierungsausdruck lässt sich grob in drei Teile unterteilen:

format_def + % + Objekt(e)

Die Notationen %s, %d, %g usw. sind Datentypformate. Wenn Sie mit der Sprache C vertraut sind, ist dies dieselbe Syntax, die für printf() verwendet wird.

Spezifikationen verschiedene Arten Python-Daten sind in der folgenden Tabelle aufgeführt:

Format	Bedeutung
"D"	Ganzzahl dezimal.
"ich"	Ganzzahl dezimal.
"Ö"	Oktalzahl.
"Du"	Der veraltete Typ ist derselbe wie "d" .
"x"	Hexadezimalzahl (Kleinschreibung).
"X"	Hexadezimalzahl (Großbuchstaben).
"e"	Eine reelle Zahl in Exponentialform (Kleinbuchstaben).
"E"	Eine reelle Zahl in Exponentialform (Großbuchstaben).
"F"
"F"	Eine reelle Zahl in Dezimalform.
"g"	Reelle Zahl. Verwendet das Format "f" oder "e" in Kleinbuchstaben.
"G"	Reelle Zahl. Verwendet das Format „F“ oder „E“ in Großbuchstaben.
"C"	Ein Zeichen (oder Zahl).
"R"	repr() .
"S"	Eine Zeichenfolge, in die jedes Python-Objekt mithilfe von str() konvertiert wird.
"%"	Das Argument wird nicht konvertiert, es wird nur das Zeichen "%" angezeigt.

Die eingebaute format()-Funktion

Es funktioniert so: str.format()

In einem String werden „Ersatzfelder“ in geschweiften Klammern () eingeschlossen. Alles, was nicht in Klammern eingeschlossen ist, wird als reiner Text behandelt, der unverändert kopiert wird. Um die Zeichen von geschweiften Klammern im Text zu vermitteln, werden sie dupliziert: (( und )) .
Ersetzungsfelder sind wie folgt formatiert:

Ersatzfeld::= "(" [Feldname] ["!" Konvertierung] [":" Spezifikation] ")" Feldname::= Argument_Name ("." Attributname | "[" Elementnummer "]")* Argument_Name::= [ Kennung | Ganzzahl] Attributname::= Bezeichner Elementindex::= Ganzzahl | Zeichenkettenindex Zeichenkettenindex::=<любой символ кроме "]">+ Umwandlung::= "r" | "s" # str- oder repr-Spezifikation::=<описано ниже>wo
Spezifikation::= [[Stub]Ausrichtung][Zeichen][#][Breite][,][.Präzision][Typ] Stub::=<любой символ>Ausrichtung::= "<" | ">" | "=" | "^" Zeichen::= "+" | "-" | " " Breite::= Ganzzahl # Feldbreite Genauigkeit::= Ganzzahl # Dezimalstellen Typ::= "b" | " c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | " %" So geschrieben: >>> print """\n(0) ... An der Wand sitzen... (0) ... Im Schlaf runtergefallen.""".format("Humpty Dumpty" ) Humpty Dumpty Saß an der Wand Humpty Dumpty Fiel im Schlaf herunter.

Wie Sie sehen können, ist diese Methode viel flexibler als der „%“-Operator, da wir die gleichen Werte wiederholt und in beliebiger Reihenfolge verwenden können. Sie können auch benannte Argumente übergeben, auf die wir dann nicht mit Zahlen, sondern mit Namen verweisen.

Noch ein Formatierungsbeispiel:

>>> toc = (... ("Erstes Kapitel", "3"), ... ("Zweites Kapitel", "150") ...) >>> for line in toc: ... print( "(:.

Übersetzung

Ich warte auf Kommentare zu Fehlern im Design und Tippfehlern in einem persönlichen - traditionellen habraplyushki von mir.

Ich schreibe seit vielen Jahren in Python. Aber ganz am Anfang dieser Reise war ich daran interessiert zu lernen, wie man Strings im Perl-Stil formatiert. Ich möchte Sie daran erinnern, dass Perl (und viele Unix-Befehlszeileninterpreter) zwei Arten von Zeichenfolgenliteralen unterstützen - mit einfachen Anführungszeichen (wenn die Zeichenfolge unverändert gedruckt wird) und doppelten Anführungszeichen, bei denen ihre Werte Variablen ersetzen. In Perl können Sie zum Beispiel so etwas schreiben wie:

$name = "Reuven"; print "Hallo, $name\n";
Und das Programm wird dementsprechend "Hello, Reuven" schreiben.

In meinen Python-Lektionen habe ich immer str.format erwähnt, aber in bestimmten Beispielen stützte sich meistens alles auf %. Ich habe die Schüler sogar ermutigt, % zu verwenden, da ich es persönlich viel einfacher fand.

Wie würde dieses Beispiel im Fall von str.format aussehen? Ziemlich ähnlich:

>>> "Guten Morgen, () ()".format(first, last) "Guten Morgen, Reuven Lerner"
Bitte beachten Sie, dass wir das Prinzip leicht verändert haben. Das ist jetzt kein binärer Operator für Strings, sondern eine Methode des String-Objekts, die eine Reihe von Parametern entgegennimmt. Das ist logisch und konsequenter. Für dieselben Schüler sah der %-Operator in meinen Beispielen wie eine Ergänzung zu print aus, nicht wie eine Zeichenfolgenoperation. Die „.format“-Notation nach der Zeichenfolge macht deutlicher, dass es sich um eine für diese Zeichenfolge spezifische Methode handelt.

Der Punkt, an dem str.format den ersten Vorteil gegenüber % zeigt, ist, wenn Parameter in umgekehrter Reihenfolge verwendet werden müssen. Tatsächlich gibt es mit %s überhaupt keine Möglichkeit, dies zu erreichen. Es ist auch nicht möglich, den Wert derselben Variablen mehr als einmal zu verwenden. Bei Verwendung von str.format können wir die Ersetzungsreihenfolge einfach ändern:

Natürlich können Sie auch eine Sequenz aus einer Liste mit dem *-Operator verwenden:

>>> names = ("Reuven", "Lerner") >>> "Guten Morgen, () ()".format(*names) "Guten Morgen, Reuven Lerner"
Sie können auch benannte Argumente verwenden:

>>> "Guten Morgen, (erster) (letzter)".format(first="Reuven", last="Lerner") "Guten Morgen, Reuven Lerner"
Diese Möglichkeit gefällt mir besonders gut. Benannte Parameter sind expliziter (wenn sie gute Namen haben) und die Verwendung von (first) und (last) ist gut lesbar - insbesondere im Vergleich zu %(first)s, das mit dem %-Operator benötigt wird

Benannte Parameter können auch mithilfe des **-Operators aus einem Wörterbuch erweitert werden:

Es sollte erwähnt werden, dass benannte und positionelle Argumente technisch zusammen verwendet werden können. Aber es ist besser, dies nicht zu tun:

>>> person = ("first":"Reuven", "last":"Lerner") >>> "Gut (0), (first) (last)".format("morning", **person) " Guten Morgen Reuven Lerner"

Ich warnte.

>>> "Ihr Name ist (name:10)".format(name="Reuven") "Ihr Name ist Reuven "
(Beachten Sie, dass die Zeichenfolge nach dem Namen mit Leerzeichen aufgefüllt wird.)

Wenn Sie die Ausrichtung auf der rechten Seite des Blocks festlegen müssen, verwenden Sie das Zeichen > zwischen: und der Zahl:

>>> "Der Preis beträgt $(number).".format(number=123) "Der Preis beträgt $123."
Aber es gibt mehr Modifikatoren für Zahlen als für Strings. Um beispielsweise eine Zahl in binärer Form anzuzeigen, fügen Sie den Modifikator "b" hinzu, wenn sie hexadezimal ist, den Modifikator "x":

Zum Beispiel:

>>> "Ihre Lieblingszahl ist (n).".format(n=Zahlen) "Ihre Lieblingszahl ist 3."
Aber:

>>> person = ("first":"Reuven", "last":"Lerner") >>> "Ihr Name ist (p).".format(p=person) "You name is Reuven."
Beim Versuch, Anführungszeichen zu verwenden, erhalten wir eine Ausnahme ...

Sie können Ihren Klassenobjekten sogar benutzerdefinierte Formatierungsregeln hinzufügen, sodass sie einen bestimmten Rendering-Stil und Modifikatoren haben, um ihn anzupassen.

Wenn Sie dieses Thema genauer untersuchen möchten, sollten Sie mit PEP 3101 beginnen, das str.format beschreibt. Empfehlen kann ich auch den Vortrag von Eric Smith mit einer recht guten Zusammenfassung zu diesem Thema. Es gibt auch gute Beispiele, wie man von der Verwendung von % zu str.format in der Python-Dokumentation wechselt

Ich hoffe, es hat euch gefallen!

Siegel

Auch interessant:

Schneller Start. Yandex.Webmaster: Überblick über die wichtigsten Tools Überblick über das Hauptfenster in Yandex Webmaster

Yandex Webmaster: Gebrauchsanweisung

Verdienst mit sofortiger Geldabhebung ohne Investitionen

Wir empfehlen Lektüre:

2022-03-06 06:41:17

Holen Sie sich Abonnenten der VK-Gruppe: kostenlose und kostenpflichtige Möglichkeiten

2022-03-06 06:41:17

Abonnements und Abonnenten in VK: was Sie darüber wissen müssen

2022-03-06 06:41:17

Wie kennzeichne ich, dass der Artikel verkauft ist?

Fortsetzung des Themas:

Smart-TV

Verdienen Sie Geld, indem Sie Videos auf YouTube ansehen

Millionen von Nutzern sehen sich täglich Videos auf YouTube an. Und natürlich wird dies für viele Unternehmen zu einer hervorragenden Motivation, ihre Anzeigen auf dem Dienst zu platzieren....