Willkommen zurück.
Lassen Sie uns eine lustige kleine Übung machen, indem wir einen Code, den wir zuvor geschrieben haben, noch
einmal ansehen. Erinnern wir uns an das Zufallsspiel, bei dem wir eine Zahl zwischen eins und zehn erraten mussten, wenn ich diese Datei ausführe, sehen Sie
das?
Es forderte mich auf zu raten.
Sagen wir eins, zwei, drei, vier, fünf, sechs, sieben, acht, neun.
Und endlich bekomme ich die Nummer.
Du bist ein Genie.
Die Zahl war neun.
Wie können wir diesen Code jetzt testen?
Eine Sache, die Sie hier bemerken werden, ist, dass wir nicht wirklich eine Funktion haben.
Ich erinnere mich, als ich Ihnen über funktionale Programmierung erzählte und wie gut es ist,
unseren Code in kleine Funktionen aufzuteilen, die eine Sache und eine Sache wirklich gut machen, insbesondere reine Funktionen.
Nun, einer der großen Vorteile dieser Mentalität besteht darin, dass Sie Code erstellen, der wirklich, wirklich einfach zu testen
ist.
Anstatt wirklich komplizierte Logik in unseren Tests zu haben, können wir unseren Funktionen einfach eine
Eingabe geben und eine Ausgabe erwarten, und deshalb haben wir Unit-Tests.
Und die Idee eines Unit-Tests ist, dass wir jedes Stück einer Unit testen.
Diese Unit-Tests sind kleine kleine Teile, die diese einfachen Funktionen testen.
Meine Herausforderung an Sie besteht also darin, diesen Code zu verwenden und zu versuchen, ihn in einfache Funktionen aufzuteilen.
Jetzt.
In unserem Fall möchte ich, dass wir nur diesen Teil des Codes testen, den erratenden Teil, bei dem wir eine Eingabe
erhalten.
Das ist die Vermutung und testet sie dann mit einer zufälligen Antwort, die wir haben, und wir sollten eine Art
Ausgabe erwarten.
Entweder geben wir eine Nr.
Es muss eins zu 10 sein, und wenn wir es richtig machen, müssen wir die Zeichenfolge bekommen.
Aber der Schlüssel hier ist, dass wir dies wahrscheinlich in eine Funktion verschieben möchten, die wir testen können, wir können
die Außenwelt ignorieren.
Und zerlegen Sie dies in seine eigene kleine Funktion.
Also pausiere das Video hier.
Probieren Sie es aus.
Sie werden einige Stolpersteine überwinden müssen, aber es wird Ihr Verständnis von Tests wirklich auf die Probe
stellen.
Haha.
Komisch, das war ein Onkel.
Also lass das Video weiter, probier es aus, sonst fange ich mit der Antwort an.
Als erstes möchte ich meinen Test neu einrichten, den Komponententest importieren und die
Klasse test main erstellen.
Oder nennen wir dieses Mal ein Testskript oder ein Testspiel.
Ich werde sagen, Unit-Test-Punkt-Testfall.
Dies wird unser Testfall sein, und dann erstelle ich hier, sagen wir, nur einen einfachen Testfall.
Spiel- oder Testeingabe?
Empfange das Selbst.
Und im Moment werde ich das einfach passieren, weil wir nicht wirklich etwas tun.
Abschließend sage ich, ob.
Name, denn bei mir läuft dann der Unit-Test.
Punkt Hauptsache.
Dies ist also nur unser einfaches Setup.
Wenn wir dies jetzt ausführen, sagen wir Python drei.
Testen Sie durch.
Sie sehen, wir haben einen Test durchgeführt.
In Ordnung, das ist also unser Setup als nächstes. Was ich tun möchte, ist, dies tatsächlich herauszunehmen, damit ich es in
meiner Testdatei verwenden kann, indem ich es in eine Funktion extrahiere.
Also sage ich hier ganz oben.
Ich werde unsere Vermutung definieren.
Gewinnen oder nennen wir es Ron.
Vermuten.
Das wird eine Eingabe erhalten.
Oder sagen wir eine Vermutung, und dann wird dieser Code ausgeführt, also lassen Sie uns das tun.
Ich werde nehmen.
Dieses Stück Code.
So was.
Und einfach hier einfügen.
Nun wird die falsche Schätzung auch die Antwortvariable benötigen, daher werde ich ihr eine zweite Parameterantwort
geben.
So, dass ich jetzt einfach hier rein kann.
Führen Sie diese Funktion mit den Gästen aus und antworten Sie.
Genau so.
Speichern wir sie also hier und führen Sie diesen Test durch, oder führen wir einfach die eigentliche Datei aus, um sicherzustellen, dass sie noch
funktioniert.
Und wir haben dort eine kleine Einrückung, also müssen wir sicherstellen, dass unsere Einrückung korrekt ist, denn denken Sie
daran, dass das in Python etwas bedeutet.
In Ordnung, jetzt haben wir ein Problem, wir haben eine Pause außerhalb der Schleife, denn während wir
das Schlüsselwort Pause verwenden und wir uns gerade außerhalb einer Schleife befinden.
Wir können also nur sagen, dass wir hierher zurückkehren.
Lassen Sie uns das also noch einmal ausführen.
Und erraten Sie immer wieder einen Namen.
Oder eine Nummer, und los gehts.
Das funktioniert immer noch, ich kann hier Return verwenden, weil dieser Brunnen laufen und zurückkehren wird, aber jetzt sind wir
immer noch im Spiel.
Vielleicht können wir also einfach zurückkehren.
Wahr.
Und sagen Sie, wenn.
Lauf Vermutung.
Es ist wahr, wir werden daraus ausbrechen.
Beginnen wir wieder unser Spiel.
Ich werde das einfach löschen und das Spiel erneut starten.
Eins zwei drei vier.
Und los gehts.
Ich habe ein Nein eingegeben, ich bin ein Genie, wir haben gerade das Spiel beendet.
Lassen Sie uns dies etwas kleiner machen, damit Sie es sehen können.
Wir haben also unseren Lauf vermuten lassen, dass ich den Code ein wenig modifiziert habe.
Aber das Wichtigste ist, dass ich eine Funktionseinheit herausgezogen habe, damit ich so etwas wie Laufraten testen
kann.
Es sieht also so aus, als hätte ich unseren Code geändert, aber der Code funktioniert noch.
Lassen Sie uns nun damit beginnen, unsere falschste Funktion zu testen.
Lass uns hierher gehen.
Und beginnen Sie mit dem Importieren unseres Skripts.
Und hier drin, tun Sie zuerst ein paar Dinge, ich möchte, dass die Antwort, sagen wir, fünf ist.
Und die Schätzung wird gleich fünf sein, also möchten wir sicherstellen, dass Sie ein Genie sind
oder in unserem Fall wahr zurückgeben, wenn die Gäste und die Antwort so übereinstimmen, dass die falschen Gäste die if-Anweisung
durchlaufen und ausgeben .
Sagen wir also, Autodidakt behauptet.
Gleich.
Lassen Sie uns dieses Skript oder beim ersten Mal tatsächlich ausführen, also haben wir ein Ergebnis
gleich dem Skript-DOT.
Was war es, Rodrguez?
Führen Sie eine Vermutung aus und geben Sie die Antwort und raten Sie.
Und wir erwarten das Ergebnis.
Gib true zurück, also können wir einfach sagen, dass das wahr ist.
Das Ergebnis stimmt, wenn ich das jetzt ausführe.
Oh, wir starten das Spiel tatsächlich, also wie können wir das beheben?
Nun, wir können dies schließen und tatsächlich den if-Namen main hinzufügen.
Hier drin.
Also hier unten.
Wir sagen, hey, führen Sie dies nur aus, wenn dies die Hauptdatei ist, die einfach so ausgeführt wird.
Wenn ich hier zurückkehre, um zu testen, und dies erneut ausführen.
In Ordnung, jetzt funktioniert es, aber ich bekomme eine Assertion Lufttest-Spielobjekt hat kein Attribut assert true, weil, nun
ja, ich.
Schreibe das falsch.
Versuchen wir es noch einmal.
Alles klar, es sieht so aus, als wäre ein Test gelaufen und alles ist gut.
Wir sehen auch, dass aufgedruckt du bist ein Genie, sehr, sehr nett.
Übrigens zeige ich Ihnen diese Art des Testens, weil so ein reales Szenario aussieht.
Sie machen immer wieder Dinge kaputt, machen immer wieder Fehler, und dann versuchen Sie, sie zu reparieren und Ihren Code zu
korrigieren.
Und Sie können sehen, dass unser Code bereits jetzt immer besser aussieht, wenn Sie diese Tests ausführen.
OK, was können wir sonst noch tun, sagen wir, hier?
Dass wir dies kopieren werden und es nur kürzer ist, ich werde die Parameter hier einfach
direkt eingeben.
Genau so.
Sagen wir Geschmackseingabe, sagen wir falsch.
Oder.
Falsch geraten.
Sagen wir also, die Antwort ist fünf und ich schätze null.
Wir wollen also behaupten, dass dies gleich falsch ist.
Wenn ich das also durchführe, bestehen zwei Tests, das ist großartig.
Was können wir hier noch testen?
Okay, gut, wir wollen testen, dass, wenn die Schätzung nicht zwischen null und 10 oder zwischen eins und 10 liegt, wir in diesem
Fall einen Ausdruck von, hey, bozo, ich sagte eins bis zehn haben wollen.
Also kann ich nochmal testen.
Das ist, wenn meine Vermutung falsch ist.
Nein.
Sagen wir, die Antwort ist fünf, aber ich gebe 11.
Wir wollen behaupten.
Nun, im Moment drucken wir und tun nichts, also sollten wir vielleicht false zurückgeben, nur um hier eine gewisse Konsistenz
zu haben.
Auch wenn ich das tue und ich laufe.
Da gehst du.
Drei Tests werden bestanden, das ist großartig, und es gibt noch viele, viele weitere Tests, die wir schreiben können.
Vielleicht machen wir noch einen Test, nämlich zu testen.
Was ist, wenn die Eingabe eine Zeichenfolge ist?
Wenn ich das laufe.
Und stellen Sie sicher, dass das falsch ist.
Geben Sie hier ein, stellen Sie sicher, dass die Namen unterschiedlich sind.
Und ich habe vier Tests laufen.
Denn dies wird nicht passieren und es wird false zurückgeben.
Wir können hier noch viel mehr tun, aber Sie können die Macht des Tests jetzt sehen, wenn Sie einen anderen
Test als ich haben.
Das ist in Ordnung, alle.
Testfälle sind unterschiedlich.
Der springende Punkt beim Testen ist einfach.
Schauen Sie sich unseren Code an und sehen Sie, wie wir ihn verbessern können, wie wir unseren Code brechen können, wie
wir unseren Code vereinfachen können, indem wir ihn in kleinere Einheiten zerlegen, kleinere Einheiten, die getestet werden können und einige Fehler beheben, an die wir
vielleicht nicht gedacht hätten Über.
Jetzt können wir noch viel mehr tun.
Aber Sie bemerken hier, wie die Idee war, an einem kleinen Stück zu einer Zeit getestet zu arbeiten.
Und dann können wir uns vielleicht weiter diesen Teil des Codes ansehen oder vielleicht den Try-and-Accept-Teil des Codes.
Und hier ist die Sache, wenn Sie für ein Unternehmen arbeiten, behaupte ich, dass Sie unendlich viele Tests
durchführen können.
Sie können hier Hunderte von Zeilen haben, um Ihren Code in Bits zu testen.
Aber nur weil Sie so oft wie möglich testen, werden Ihre Tests nicht wirklich gut.
Wie gesagt, es gibt unendlich viele Tests, die Sie schreiben können.
Die Idee ist, qualitativ hochwertige Tests zu schreiben, die die meisten Ihrer Fälle abdecken, aber schließlich werden Sie weniger Ergebnisse erzielen,
wenn Sie einen Kompromiss zwischen dem Schreiben von Code und dem Schreiben von Tests eingehen müssen.
Und manchmal müssen Sie sich je nach den Anforderungen des Jobs möglicherweise mehr auf Tests und weniger auf
Code konzentrieren.
Oder manchmal müssen Sie schnell handeln und haben keine Zeit, Tests zu schreiben.
Und je nach geschäftlichen Anforderungen kann dies auch der Fall sein.
Aber mit diesem Abschnitt hoffe ich, dass Sie einige der Prinzipien verstehen, die dem Testen in der Softwareentwicklung folgen.
Das heißt, Fehler werden in unserem Code immer auftreten.
Und wir können Lintang verwenden, um uns dabei zu helfen, aber eine der besten Möglichkeiten, um sicherzustellen, dass unser Code
richtig funktioniert, ist das Testen.
Und je mehr Tests wir normalerweise haben, desto stabiler ist unser Code.
Ich werde in der nächsten sehen, tschüss.