Verwendung von Python zur Implementierung des „Text PK“-Spiels
Vorwort
Ich möchte zunächst mit Ihnen darüber sprechen, wie ein Projekt im Allgemeinen abgeschlossen wird. Genauer gesagt: Wie denken und lösen Programmierer Probleme?
Ich denke, eine der wichtigsten Fähigkeiten ist [Problemzerlegung]. Unter Problemzerlegung versteht man, wenn man etwas tut oder mit einem Problem konfrontiert wird, es in mehrere Schritte oder Ebenen zerlegt und das Problem schrittweise ausführt und löst, bis das Endergebnis erreicht ist.
Ich werde den Prozess des Abschlusses eines Projekts in den folgenden drei Schritten zusammenfassen: Die
Klärung der Projektziele bezieht sich darauf, welchen Zweck das Programm erreichen soll und welche Funktionen es erfüllen kann, was uns dabei hilft, das Projekt in verschiedene Einheiten aufzuteilen; und eine ordnungsgemäße Zerlegung Der Plan mit mäßig zunehmendem Schwierigkeitsgrad kann uns dabei helfen, das Projekt schrittweise und reibungslos auszuführen und schließlich abzuschließen. Man kann sagen, dass diese drei Schritte ineinandergreifen.
Dann beginnen wir offiziell mit der praktischen Durchführung des Projekts. In diesem Prozess müssen Sie Ihr Gehirn und Ihre Hände stärker einsetzen.
Projektziele klären
Die Anforderung, die wir dieses Mal erfüllen wollen, ist: Mensch-Maschine-PK-Minispiel. Spezifische Effekte entnehmen Sie bitte dem Diagramm unten.
Um es einfach auszudrücken: In diesem Spiel werden die Attribute des Spielers und des Feindes zufällig generiert und sie greifen sich gegenseitig gleichzeitig an, bis die Gesundheit einer Partei weniger als Null ist.
Darüber hinaus dauert ein solcher Kampf drei Runden im Best-of-Three-Rundensystem. Am Ende wird das Kampfergebnis ausgegeben und der Gewinner bekannt gegeben.
Nachdem klar ist, welche Wirkung das Projekt erzielen soll, kann das Projekt abgebaut werden.
Analysieren Sie den Prozess und bauen Sie das Projekt ab
Beim Schreiben von Code müssen wir nicht strikt darauf achten, alles in einem Schritt richtig zu machen. Insbesondere für Programmier-Neulinge lassen sich bessere Übungsergebnisse erzielen, indem der Schwierigkeitsgrad schrittweise erhöht wird.
Um Sie aufzuwärmen und den Lernrhythmus der meisten Schüler zu berücksichtigen, teile ich das Minispiel, das wir implementieren möchten, unter dem Gesichtspunkt „Überlagerung von Funktionen und zunehmender Schwierigkeit“ in drei Versionen auf.
Version 1.0 hilft uns hauptsächlich dabei, die Kampflogik zu klären. Die Versionen 2.0 und 3.0 beinhalten einige neue Wissenspunkte. Ich werde sie Ihnen vorstellen, wenn Sie darauf stoßen.
Wenn das Projekt klar aufgeschlüsselt ist, müssen Sie es nur noch Schritt für Schritt ausführen, d. h. den Zyklus „Ausführen → Probleme begegnen → Probleme lösen → Ausführung fortsetzen“ wiederholen.
Beginnen wir als Nächstes damit, den Code offiziell zu schreiben. Lassen Sie uns ihn Version für Version erobern!
Schritt-für-Schritt-Ausführung, Code-Implementierung
Schauen wir uns zunächst an, wie Version 1.0 implementiert wird.
Version 1.0: Benutzerdefinierte Attribute, manuelle PK
In der ersten Phase des Codes besteht unsere Hauptaufgabe darin, die Logik des Kampfes zu klären und dann die Funktion print() zu verwenden, um den Kampfprozess auf dem Terminal auszudrucken.
Lassen Sie uns zunächst darüber nachdenken, was die grundlegendsten Elemente eines Mensch-Maschine-PK-Spiels sind. Wir können das klassischste King of Fighters-Spiel verwenden, um es herauszufinden.
Gemäß den Einstellungen dieser Version müssen wir drei Hauptschritte ausführen: 1. Geben Sie die Attribute des Spielers und des Feindes an und zeigen Sie sie an. 2. Beide Seiten greifen sich gleichzeitig an und die Blutmenge wird erhöht entsprechend der Angriffskraft des Gegners abgezogen. 3. Wenn das Gesundheitsvolumen einer Partei weniger als 0 beträgt, ist das Spiel vorbei.
Um unser Denken klar zu halten, ist das Flussdiagramm wie folgt aufgebaut:
Sagen Sie nicht, dass Sie normalerweise keine Spiele spielen und nicht wissen, wie man es macht. Alle Schritte in dieser Version sind nicht sehr „intelligent“ und verwenden nur die einzige Funktion Print(). Mit anderen Worten: Wir müssen die Schritte nur einzeln ausdrucken und es wird als erfolgreich angesehen.
Okay, beginnen wir mit Schritt 1: Legen Sie die Attribute von [Spieler] und [Feind] fest, nämlich [Blutvolumen] und [Angriff].
print('【玩家】血量：100 攻击：50') # 自定义玩家角色的血量和攻击
print('【敌人】血量：100 攻击：30') # 自定义敌人角色的血量和攻击
Schritt 2: Berechnen Sie manuell das verbleibende Blutvolumen beider Seiten nach einem Angriff.
print('你发起了攻击，【敌人】剩余血量50') # 人工计算敌人血量：100-50=50
print('敌人向你发起了攻击，【玩家】剩余血量70') # 人工计算玩家血量：100-30=70
Schritt 3: Führen Sie weiterhin manuelle Berechnungen durch: Wenn der Spieler den Feind zweimal angreift, ist das Blutvolumen des Feindes gleich 0. Zu diesem Zeitpunkt kann der Kampf beendet und die Spielergebnisse ausgedruckt werden.
print('你发起了攻击，【敌人】剩余血量0') # 双方同时攻击，若血量出现小于等于0，游戏结束
print('敌人向你发起了攻击，【玩家】剩余血量40')
print('敌人死翘翘了，你赢了！') # 打印结果
Es ist sehr einfach! Was wir jetzt tun müssen, ist, diese drei Codeteile zusammenzufügen, und dann werde ich einige visuell modifizierte Zeilenumbrüche und Trennlinien hinzufügen, um die laufenden Ergebnisse klarer zu machen.
print('【玩家】\n血量：100\n攻击：50') # 自定义玩家角色的血量和攻击，用换行符'\n'来优化视觉
print('------------------------') # 辅助功能，起到视觉分割的作用，让代码的运行结果更清晰
print('【敌人】\n血量：100\n攻击：30')
print('------------------------')
print('你发起了攻击，【敌人】剩余血量50') # 人工计算敌人血量：100-50=50
print('敌人向你发起了攻击，【玩家】剩余血量70') # 人工计算玩家血量：100-30=70
print('------------------------')
print('你发起了攻击，【敌人】剩余血量0') # 双方同时攻击，若血量出现小于等于0，游戏结束
print('敌人向你发起了攻击，【玩家】剩余血量40')
print('-----------------------')
print('敌人死翘翘了，你赢了！') # 打印结果
Versuchen Sie es auszuführen.
Operationsergebnis:
print('【玩家】\n血量：100\n攻击：50') # 自定义玩家角色的血量和攻击，用换行符'\n'来优化视觉
print('------------------------') # 辅助功能，起到视觉分割的作用，让代码的运行结果更清晰
print('【敌人】\n血量：100\n攻击：30')
print('------------------------')
print('你发起了攻击，【敌人】剩余血量50') # 人工计算敌人血量：100-50=50
print('敌人向你发起了攻击，【玩家】剩余血量70') # 人工计算玩家血量：100-30=70
print('------------------------')
print('你发起了攻击，【敌人】剩余血量0') # 双方同时攻击，若血量出现小于等于0，游戏结束
print('敌人向你发起了攻击，【玩家】剩余血量40')
print('-----------------------')
print('敌人死翘翘了，你赢了！') # 打印结果
Hmm ... Obwohl es ein wenig interessant erscheint, werden alle Informationen auf einmal angezeigt und spiegeln überhaupt nicht den Fortschritt des Spiels wider.
Damit die gedruckten Dinge nacheinander in Zeitintervallen erscheinen, müssen wir daher etwas Ähnliches wie einen „Timer“ einrichten. In Python müssen wir zur Implementierung zwei Codezeilen verwenden: (Klopfen Sie an die Tafel, sehr einfaches neues Wissen)
import time #调用time模块
time.sleep(secs)
#使用time模块下面的sleep()函数，括号里填的是间隔的秒数（seconds，简称secs）
#time.sleep(1.5)就表示停留1.5秒再运行后续代码
Hier gibt es einen neuen Begriff – Modul. Es handelt sich um ein wichtiges Konzept in Python. Ich werde es Ihnen in einem späteren Artikel ausführlich vorstellen.
Sie können sich ein Modul wie eine Schatztruhe vorstellen, die viele magische Funktionen enthält. Wenn Sie jedoch die Funktionen in dieser Schatztruhe nutzen möchten, müssen Sie sie zunächst mit einem Code wie „Modulname importieren“ öffnen.
Dann möchten wir hier die Funktion „sleep()“ im Zeitmodul verwenden, was bedeutet, dass die Ergebnisse der Codeausführung nicht auf einmal, sondern stapelweise angezeigt werden. Es muss in der Form time.sleep(secs) geschrieben werden.
Wenn ich die gedruckten Informationen so einstellen möchte, dass sie alle 1,5 Sekunden erscheinen, kann der Code so geschrieben werden:
import time #通常import语句会写到代码的开头
print('【玩家】\n血量：100\n攻击：50')
print('------------------------')
time.sleep(1.5)
#暂停1.5秒，再继续运行后面的代码
print('【敌人】\n血量：100\n攻击：30')
print('------------------------')
time.sleep(1.5)
#同上
print('你发起了攻击，【敌人】剩余血量50')
print('敌人向你发起了攻击，【玩家】剩余血量70')
print('------------------------')
time.sleep(1.5)
print('你发起了攻击，【敌人】剩余血量0')
print('敌人向你发起了攻击，【玩家】剩余血量40')
print('-----------------------')
time.sleep(1.5)
print('敌人死翘翘了，你赢了！')
Okay, jetzt, da wir den Code verstanden haben, lassen Sie uns ihn direkt ausführen, um den Effekt zu sehen.
Huh ~ Ich habe endlich Version 1.0 fertiggestellt, aber ich denke, Sie beschweren sich im Stillen darüber, dass die Verwendung von print() zum Schreiben jedes Satzes zu dumm und zu schwach ist.
Stimmt, aber der Code muss Schritt für Schritt implementiert werden. Betrachten Sie es einfach als ein kleines Aufwärmen.
Darüber hinaus weist diese Version des Codes zwei offensichtliche Mängel auf: Erstens werden die Attribute (Gesundheitsvolumen und Angriff) des Spielers und des Feindes von mir festgelegt, sodass keine Spannung über das Ergebnis besteht; zweitens die Änderung des Gesundheitsvolumens während Die Schlacht. Wenn Sie es manuell berechnen müssen, welchen Nutzen hat dann ein Computer?
Keine Sorge, das sind alles Probleme, die wir in Version 2.0 lösen werden.
Version 2.0: Zufällige Attribute, automatische PK
Wie bereits erwähnt, fügen wir in dieser Phase hauptsächlich zwei neue Funktionen hinzu: [Zufälliges Attribut] und [Automatischer Kampf]. Das Flussdiagramm sieht folgendermaßen aus: Denken Sie darüber nach: Die Attribute beider Charaktere selbst zu definieren, ist einfach
eine Black Box . Operation, der Ausgang steht bereits fest. Um das Spiel fair zu gestalten, müssen wir daher die Attribute ändern, die nicht mehr von uns selbst bestimmt werden, sondern zufällig generiert werden.
Jetzt kommt das Problem. Wir müssen Attribute (Zahlen) zufällig generieren, was in diesem Artikel nicht behandelt wird. was zu tun?
Probieren Sie es selbst aus, es wird online verfügbar sein.
Dies ist auch meine am meisten empfohlene Vorgehensweise. Wenn Sie das Problem selbstständig lösen können, werden Sie super zufrieden sein.
Nachdem Sie nun ein gewisses Maß an Code-Lesefähigkeiten beherrschen, können Sie die meisten Ihrer aktuellen Probleme tatsächlich lösen, wenn Sie auf einen steckengebliebenen Punkt stoßen und online suchen. „Schlagen Sie nach, wenn Sie es nicht verstehen“ ist auch eine der Arbeitsgewohnheiten von Programmierern.
Nach einer Suche im Internet haben wir festgestellt, dass es einen solchen Effekt gibt:
Aus diesem Text können wir ersehen, dass wir zum zufälligen Generieren von Ganzzahlen die Funktion randint () im Zufallsmodul verwenden müssen. In den Klammern stehen zwei Ganzzahlen Beschreiben Sie die zufällige Erzeugung von ganzen Zahlen. Bereich.
Beispielcode:
import random
#调用random模块，与
a = random.randint(1,100)
# 随机生成1-100范围内（含1和100）的一个整数，并赋值给变量a
print(a)
Operationsergebnis:
73
Nachdem Sie nun den Zufallsgenerator beherrschen, machen wir zum Üben eine kleine Übung:
Bitte hören Sie sich die Fragen an: 1. Definieren Sie zwei Variablen, um die Werte des Blutvolumens und der Angriffskraft des Spielers zu speichern. 2. Das Blutvolumen ist eine Zufallszahl zwischen 100 und 150 und die Angriffskraft ist a Zufallszahl zwischen 30 und 50. 3. Drucken Sie die beiden Variablen aus.
Beispielcode:
import random
player_life = random.randint(100,150)
#表示玩家血量
player_attack = random.randint(30,50)
#表示玩家攻击
print(player_life)
print(player_attack)
Operationsergebnis:
玩家的血量是：115
玩家的攻击力是：32
Okay, wir wissen bereits, wie man zufällige Attribute generiert. Jetzt drucken wir die Attributanzeige aus. Bitte lesen Sie den folgenden Code, um die Bedeutung jeder Zeile zu verstehen:
import time
import random
#也可合并写成一行：import time,random
# 生成随机属性
player_life = random.randint(100,150) # “player_life” 代表玩家血量
player_attack = random.randint(30,50) # “player_attack” 代表玩家攻击
enemy_life = random.randint(100,150) # “enemy_life” 代表敌人血量
enemy_attack = random.randint(30,50) # “enemy_attack” 代表敌人攻击
# 展示双方角色的属性
print('【玩家】\n'+'血量：'+str(player_life)+'\n攻击：'+str(player_attack))
#player_life和player_attack的数据类型都是整数，所以拼接时需要先用str()转换
print('------------------------')
time.sleep(1)
#暂停一秒再执行后续代码
print('【敌人】\n'+'血量：'+str(enemy_life)+'\n攻击：'+str(enemy_attack))
print('------------------------')
Bisher haben wir die zufällige Generierung und Anzeige von Attributen abgeschlossen. Als Nächstes werden wir den „automatischen Kampf“ implementieren.
Wie erreicht man einen automatischen Kampf? Wenn Sie verwirrt sind, können Sie zunächst versuchen, die Regeln aus dem künstlichen Kampf der Version 1.0 zu finden:
print('【玩家】 血量：130 攻击：50')
print('【敌人】 血量：150 攻击：40')
print('你发起了攻击，【敌人】剩余血量100')
print('敌人向你发起了攻击，【玩家】剩余血量90')
print('------------------------')
print('你发起了攻击，【敌人】剩余血量50')
print('敌人向你发起了攻击，【玩家】剩余血量70')
print('-----------------------')
print('你发起了攻击，【敌人】剩余血量0')
print('敌人向你发起了攻击，【玩家】剩余血量40')
print('-----------------------')
print('敌人死翘翘了，你赢了！')
Wir können feststellen, dass die Zeilen 4-6 wiederkehrende Strukturen sind. Bis auf die flexiblen Zahlenänderungen ist der Rest genau gleich.
Was sollten wir zu diesem Zeitpunkt basierend auf dem Wissen, das wir gelernt haben, verwenden, um sich wiederholende Aufgaben zu lösen?
Schleifenanweisung.
Apropos Schleifen: Wir müssen darüber nachdenken, ob wir eine for-Schleife oder eine while-Schleife verwenden.
Denn jetzt werden die Gesundheit und der Angriff beider Seiten zufällig generiert und nicht festgelegt. Wir wissen also nicht genau, wie viele Runden wir kämpfen müssen, um den Gewinner zu ermitteln, das heißt, die Anzahl der Schleifen ist nicht klar, daher müssen wir natürlich eine While-Schleife verwenden.
Denken wir weiter: Welche Bedingungen sollten folgen, d. h. unter welchen Bedingungen wird der Kampfprozess weitergehen?
Wenn die Gesundheit beider Seiten größer als 0 ist, wird der Kampf fortgesetzt.
Wir haben nun festgestellt, dass die Bedingungen erfüllt sein müssen, damit der Zyklus ausgeführt werden kann: Das Blutvolumen beider Parteien ist größer als Null, das heißt, der Tod wird kein Ende nehmen.
Es ist ersichtlich, dass nach einer Weile zwei Bedingungen erfüllt sein müssen, das heißt, diese beiden Bedingungen müssen gleichzeitig wahr sein, daher müssen wir und zum Verbinden verwenden, ausgedrückt im Code:
while (player_life >= 0) and (enemy_life >= 0):
#and两边的条件分别用括号括起，是一种习惯，方便阅读
Nachdem wir nun die Bedingungen für die Ausführung der while-Schleife festgelegt haben, besteht der nächste Schritt darin, den Inhalt in die Schleife einzugeben.
Basierend auf der aktuellen Analyse hoffen wir, dass der Inhalt des Zyklus der Prozess sein wird, in dem die beiden Seiten einander angreifen und Blut verlieren.
print('你发起了攻击，【敌人】剩余血量xxx')
print('敌人向你发起了攻击，【玩家】剩余血量xxx')
print('------------------------')
Darunter: [Feind] verbleibende Gesundheit = aktuelle Gesundheit des Feindes – Angriff des Spielers, [Spieler] verbleibende Gesundheit = aktuelle Gesundheit des Spielers – Angriff des Feindes.
Tatsächlich haben wir diese vier Variablen bereits definiert. Jedes Mal, wenn wir uns gegenseitig Schaden zufügen, werden „player_life“ (Gesundheit des Spielers) und „feind_life“ (Gesundheit des Feindes) neu zugewiesen. Die Konvertierungslogik lautet also:
player_life = player_life - enemy_attack
enemy_life = enemy_life - player_attack
#赋值语句的执行顺序是先计算等号右边，再赋值给左边的变量
Okay, die Grundlogik automatischer Angriffe wurde geklärt. Lassen Sie uns zunächst den Code zusammenführen, den wir zuvor geschrieben haben.
import time,random
# 生成随机属性
player_life = random.randint(100,150)
player_attack = random.randint(30,50)
enemy_life = random.randint(100,150)
enemy_attack = random.randint(30,50)
# 展示双方角色的属性
print('【玩家】\n'+'血量：'+str(player_life)+'\n攻击：'+str(player_attack))
#player_life和player_attack都是整数类型，所以拼接时需要先用str()转换
print('------------------------')
time.sleep(1)
print('【敌人】\n'+'血量：'+str(enemy_life)+'\n攻击：'+str(enemy_attack))
print('------------------------')
time.sleep(1)
while (player_life >0) and (enemy_life > 0):
player_life = player_life - enemy_attack
enemy_life = enemy_life - player_attack
Als nächstes müssen wir nur noch die while-Schleifenanweisung abschließen, um den Prozess des automatischen Kampfes und der Blutabnahme zwischen den beiden Parteien zu schleifen.
Beispielcode:
import time,random
player_life = random.randint(100,150)
player_attack = random.randint(30,50)
enemy_life = random.randint(100,150)
enemy_attack = random.randint(30,50)
print('【玩家】\n'+'血量：'+str(player_life)+'\n攻击：'+str(player_attack))
print('------------------------')
time.sleep(1)
print('【敌人】\n'+'血量：'+str(enemy_life)+'\n攻击：'+str(enemy_attack))
print('------------------------')
time.sleep(1)
while (player_life >0) and (enemy_life > 0):
player_life = player_life - enemy_attack
enemy_life = enemy_life - player_attack
print('你发起了攻击，【敌人】剩余血量'+str(enemy_life))
#player_life是整数，所以拼接时要先用str()转换
print('敌人向你发起了攻击，【玩家】剩余血量'+str(player_life))
print('------------------------')
time.sleep(1.5)
# 为了体现出战斗回合，这里停顿1.5秒
Lassen Sie es uns direkt ausführen und die Ergebnisse sehen.
Sie sollten spüren, dass Version 2.0 endlich ordentlich aussieht und sich langsam unseren Projektzielen nähert.
Es wurde jedoch noch nicht implementiert: die Funktion, die Ergebnisse jedes Spiels auszudrucken, zwei von drei Spielen zu gewinnen und das Endergebnis auszudrucken. Dies ist, was wir in Version 3.0 hinzufügen.
Lasst uns den letzten Hügel in einem Rutsch erobern.
Version 3.0: Ergebnisse drucken, zwei von drei Spielen gewinnen
Im Vergleich zu Version 2.0 möchten wir in Version 3.0 folgende Funktionen hinzufügen: 1. Ergebnisse drucken: Nach jedem Kampf werden je nach Ergebnis von Sieg, Niederlage und Unentschieden unterschiedliche Eingabeaufforderungen gedruckt; 2. Best of Three: Beide Seiten kämpfen Nach drei Runden ist derjenige mit der höchsten Gewinnquote der endgültige Gewinner.
Ich erkläre die Neuerungen immer wieder, weil ich so die schrittweisen Ziele des Projekts kontinuierlich klären kann und mich weiterhin auf die Weiterentwicklung des Projekts konzentrieren kann.
Folgen Sie nun bitte den Anweisungen im Codebereich, um die Funktion „Ergebnisse drucken“ (Einzelspiel) zum Spiel hinzuzufügen.
Genau wie bei den Tipps, die ich gegeben habe, gibt es drei Möglichkeiten für das Ergebnis, und die entsprechenden Bedingungen sind in der folgenden Abbildung dargestellt:
Beispielcode:
import time,random
# 生成双方角色，并生成随机属性。
player_life = random.randint(100,150)
player_attack = random.randint(30,50)
enemy_life = random.randint(100,150)
enemy_attack = random.randint(30,50)
# 展示双方角色的属性
print('【玩家】\n'+'血量：'+str(player_life)+'\n攻击：'+str(player_attack))
print('------------------------')
time.sleep(1)
print('【敌人】\n'+'血量：'+str(enemy_life)+'\n攻击：'+str(enemy_attack))
print('------------------------')
time.sleep(1)
# 双方PK
while player_life > 0 and enemy_life > 0:
player_life = player_life - enemy_attack
enemy_life = enemy_life - player_attack
print('你发起了攻击，【敌人】剩余血量'+str(enemy_life))
print('敌人向你发起了攻击，【玩家】剩余血量'+str(player_life))
print('-----------------------')
time.sleep(1.5)
# 打印战果
if player_life > 0 and enemy_life <= 0:
print('敌人死翘翘了，你赢了')
elif player_life <= 0 and enemy_life > 0:
print('悲催，敌人把你干掉了！')
else:
print('哎呀，你和敌人同归于尽了！')
Okay, lass uns weitermachen. Version 3.0 hat nur noch das letzte „Best of Three Games“ übrig. Sind Sie bereit, sich der letzten Herausforderung zu stellen?
Ebenso können wir es in zwei Teile aufteilen: Zuerst drei Spiele spielen und dann das Endergebnis bestimmen.
Schauen wir uns das zunächst einmal an: Der Drei-Spiele-Kampf ist ebenfalls eine Schleifenstruktur, und die Anzahl der Schleifen ist festgelegt, sodass eine for-Schleife verwendet wird.
Hier können wir die Struktur „for i“ in „range()“ verwenden. Sehen wir uns zunächst die Funktion „range()“ an, die wir zuvor gelernt haben:
Haben Sie eine Idee? Geben Sie den Code ein und lassen Sie den Kampf drei Runden lang ablaufen. (Die Endergebnisse müssen noch nicht gezählt werden)
Zwei Tipps: 1. Überlegen Sie genau, welche Codes in der for-Schleife verschachtelt werden sollen, also welche Informationen in einem Kampf enthalten sind. Nachdem Sie festgelegt haben, wo geschrieben werden soll, müssen alle in einer Schlacht enthaltenen Informationen eingerückt werden. 2. Es müssen auch Details beachtet werden, z. B. die Unterscheidung zwischen Runden (Zeitintervall und Drucken der Informationen zur Anzahl der Runden).
Wenn es Hindernisse gibt, prüfen Sie, ob eines der oben genannten Probleme vorliegt: 1. Ist die Position der for-Schleifenanweisung korrekt? Der Schlüssel liegt darin, welche Informationen in einer Schleife angezeigt werden sollen. Beispiel: Wenn Sie die for-Schleifenanweisung versehentlich zwischen [Zufallsattribut] und [Auto-Battle] platzieren, sind die Kampfinformationen in jeder Runde gleich und es wird keine Best-of-Three-Runde geben .
2. Sind die Informationen, die eingerückt werden müssen, nachdem Sie mit dem Schreiben der for-Schleifenanweisung fertig sind, [als Ganzes] eingerückt? Wenn keine Einrückung vorhanden ist, wird möglicherweise ein Fehler gemeldet oder nur ein Teil der Kampfinformationen wird in einer Schleife angezeigt.
3. Haben Sie die Details bemerkt? Es muss eine klare Lücke zwischen den Runden geben, dann können wir time.sleep() und print('Dies ist die xte Runde') gleichzeitig verwenden, um dieses Problem perfekt zu lösen. Wenn Sie außerdem auf verschiedene Fehler stoßen, denken Sie daran, zu suchen, um herauszufinden, welcher Fehler gemeldet wird, und versuchen Sie zunächst, ihn selbst zu beheben.
Okay, schauen wir uns jetzt meine Antwort an. Bitte konzentrieren Sie sich auf die Zeilen 3 bis 5 (der folgende Inhalt sollte in die for-Schleife eingefügt werden) und führen Sie sie dann aus, um den Effekt zu sehen.
import time,random
for i in range(1,4):
time.sleep(1.5) # 让局与局之间有较明显的有时间间隔
print(' \n——————现在是第'+str(i)+'局，ready go!——————') # 作为局的标记
player_life = random.randint(100,150)
player_attack = random.randint(30,50)
enemy_life = random.randint(100,150)
enemy_attack = random.randint(30,50)
# 展示双方角色的属性
print('【玩家】\n'+'血量：'+str(player_life)+'\n攻击：'+str(player_attack))
print('------------------------')
time.sleep(1)
print('【敌人】\n'+'血量：'+str(enemy_life)+'\n攻击：'+str(enemy_attack))
print('------------------------')
time.sleep(1)
# 双方PK
while player_life > 0 and enemy_life > 0:
player_life = player_life - enemy_attack
enemy_life = enemy_life - player_attack
print('你发起了攻击，【敌人】剩余血量'+str(enemy_life))
print('敌人向你发起了攻击，【玩家】剩余血量'+str(player_life))
print('-----------------------')
time.sleep(1.5)
# 打印战果
if player_life > 0 and enemy_life <= 0:
print('敌人死翘翘了，你赢了')
elif player_life <= 0 and enemy_life > 0:
print('悲催，敌人把你干掉了！')
else:
print('哎呀，你和敌人同归于尽了！')
OK, die Vorgabe, drei Spiele zu absolvieren, hat sich auch bewährt. Jetzt sind wir nur noch einen Schritt vom endgültigen Ziel entfernt und lediglich die Funktion „Statistische Ergebnisse von zwei Siegen aus drei Spielen“ ist noch nicht implementiert.
Wir können darüber nachdenken: Wie zählen wir normalerweise die Ergebnisse von Spielen?
Wie bei einem Tischtennisspiel gilt: Wenn eine Seite eine Runde gewinnt, dreht sie die Anzeigetafel um und addiert 1 zur Zahl. Die Seite, die am Ende die höhere Zahl hat, gewinnt.
Das Gleiche gilt für Computer: Sie sind beim Denken auf Daten angewiesen, z. B. bei der Verwendung von Daten für Berechnungen, bedingte Urteile, Schleifen usw. Hier kommt es also darauf an, dem Computer Daten zu geben.
Dann kommt, dem Ansatz der Anzeigetafel folgend, unsere Lösung zum Vorschein: Bei Verwendung einer Bewertungsmethode wird für einen Sieg ein Punkt und für ein Unentschieden kein Punkt erzielt.
Daher müssen wir dem Computer eine leere „Anzeigetafel“ geben, um die Punkte von [Spieler] und [Gegner] in jeder Runde zu speichern.
player_victory = 0
#存放玩家赢的局数。
enemy_victory = 0
#存放敌人赢的局数
Unter welchen Umständen ändern sich diese beiden Variablen (+1)? Natürlich muss es mit den spezifischen Ergebnissen jedes Spiels verknüpft werden. Zu diesem Zeitpunkt können wir auf die bedingten Urteilsaussagen zur Berechnung von Gewinn oder Niederlage zurückblicken.
if player_life > 0 and enemy_life <= 0: #玩家赢
print('敌人死翘翘了，你赢了')
elif player_life <= 0 and enemy_life > 0: #敌人赢
print('悲催，敌人把你干掉了！')
else: #平局
print('哎呀，你和敌人同归于尽了！')
Dann berechnen wir die Anzahl der Runden, die der Gegner und der Spieler gewonnen haben:
player_victory = 0
enemy_victory = 0
if player_life > 0 and enemy_life <= 0:
player_victory = player_victory + 1
print('敌人死翘翘了，你赢了！')
elif player_life <= 0 and enemy_life > 0:
enemy_victory = enemy_victory + 1
print('悲催，敌人把你干掉了！')
else:
print('哎呀，你和敌人同归于尽了！')
Nach drei Runden werden „player_victory“ und „feind_victory“ neue Werte zugewiesen. Hier ist ein kleiner Trick für Sie: player_victory = player_victory + 1. Es ist etwas nervig, immer so zu schreiben. Wir können player_victory += 1 schreiben. Diese beiden Codes sind äquivalent. Sie bedeuten beide: „Wenn die Bedingung nach if erfüllt ist, wird die.“ Variable ist +1" ".
Dies ist auch ein Ausdruck des Strebens der Programmierer nach „Minimalismus“. Okay, ersetzen wir diesen Code:
player_victory = 0
enemy_victory = 0
if player_life > 0 and enemy_life <= 0:
player_victory += 1
print('敌人死翘翘了，你赢了！')
elif player_life <= 0 and enemy_life > 0:
enemy_victory += 1
print('悲催，敌人把你干掉了！')
else:
print('哎呀，你和敌人同归于尽了！')
Jetzt müssen wir nur noch die bedingte Beurteilung verwenden und die Größen der beiden Variablen vergleichen, um zu wissen, wer verliert und wer gewinnt.
Ich zeige Ihnen die Denklogik und bitte Sie dann, sie in Code umzuwandeln. Seien Sie aufmerksam und überlegen Sie: Sollte dieses bedingte Urteil eingerückt werden?
Beginnen Sie nun bitte mit der Eingabe des Codes für den letzten Schritt. Komm schon, der Sieg steht bevor!
Hast du es aufgeschrieben? Ich denke, Sie sollten kein Problem haben ~ Sehen wir uns den letzten Schritt noch einmal an. Die Umwandlung der Denklogik der bedingten Beurteilung in Codelogik ist wie folgt: Die Referenzantwort sieht also so aus. Es ist zu beachten, dass das endgültige Beurteilungsergebnis in „Außen“ platziert werden
muss die for-Schleife, das heißt, es ist keine Einrückung erforderlich.
import time,random
player_victory = 0
enemy_victory = 0
for i in range(1,4):
time.sleep(2) # 让局与局之间有较明显的有时间间隔
print(' \n——————现在是第'+str(i)+'局——————') # 作为局的标记
player_life = random.randint(100,150)
player_attack = random.randint(30,50)
enemy_life = random.randint(100,150)
enemy_attack = random.randint(30,50)
# 展示双方角色的属性
print('【玩家】\n'+'血量：'+str(player_life)+'\n攻击：'+str(player_attack))
print('------------------------')
time.sleep(1)
print('【敌人】\n'+'血量：'+str(enemy_life)+'\n攻击：'+str(enemy_attack))
print('------------------------')
time.sleep(1)
# 双方PK
while player_life > 0 and enemy_life > 0:
player_life = player_life - enemy_attack
enemy_life = enemy_life - player_attack
print('你发起了攻击，【敌人】剩余血量'+str(enemy_life))
print('敌人向你发起了攻击，【玩家】剩余血量'+str(player_life))
print('-----------------------')
time.sleep(1.5)
#打印最终战果
if player_life > 0 and enemy_life <= 0:
player_victory += 1
print('敌人死翘翘了，你赢了！')
elif player_life <= 0 and enemy_life > 0:
enemy_victory += 1
print('悲催，敌人把你干掉了！')
else:
print('哎呀，你和敌人同归于尽了！')
if player_victory > enemy_victory :
time.sleep(1)
print('【最终结果：你赢了！】')
elif enemy_victory > player_victory:
print('【最终结果：你输了！】')
else:
print('【最终结果：平局！】')
Wir haben endlich den endgültigen Code geschrieben! Wenn Sie ein Neuling sind und von Grund auf lernen, sind diese vierzig Codezeilen möglicherweise der längste Code, den Sie jemals eingegeben haben, oder? Gern geschehen, gönnen Sie sich einen Applaus!
Dies ist jedoch noch nicht vorbei. Als Programmierer ist Code unsere Visitenkarte. Wir werden einen eleganteren Code anstreben, der für andere einfacher zu lesen ist, daher gibt es im obigen Code noch Raum für Optimierung.
Daher ist das Folgende die Zeit für Easter Eggs. Am Ende dieses Levels werde ich Ihnen einen neuen Wissenspunkt beibringen: [Formatierungszeichenfolgen].
Was meinst du? Oben gibt es zwei Codezeilen, mit denen die Attribute beider Zeichen angezeigt werden:
print('【玩家】\n'+'血量：'+str(player_life)+'\n攻击：'+str(player_attack))
print('【敌人】\n'+'血量：'+str(enemy_life)+'\n攻击：'+str(enemy_attack))
Wenn wir + zum Verbinden von Zeichenfolgen und Variablen verwenden, müssen wir häufig berücksichtigen, um welchen Datentyp es sich bei der Variablen handelt. Wenn es sich nicht um einen Zeichenfolgentyp handelt, müssen wir sie zuerst mit der Funktion str() konvertieren.
Und ein Satz muss oft in mehrere Teile gespleißt werden, und dann müssen wir die Anfangsposition jedes Anführungszeichenpaares berücksichtigen, was sehr mühsam ist. Ich glaube, Sie werden etwas Erfahrung haben.
Um das Zusammenfügen verschiedener Datentypen bequemer zu realisieren, ist die Verwendung von [Formatsymbol %] daher eine gebräuchlichere und bequemere Methode.
Wir können uns % als ein Buch vorstellen, das als Platzhalter in der Bibliothek verwendet wird. Nehmen Sie zunächst eine Position ein und geben Sie später die tatsächlichen Variablen ein. Beispiel: Die beiden folgenden Schreibmethoden sind gleich. Bitte konzentrieren Sie sich auf die Syntax der zweiten Zeile.
print('血量：'+str(player_life)+' 攻击：'+str(player_attack))
print('血量：%s 攻击：%s' % (player_life,player_attack))
Wir sehen, dass nach dem Formatzeichen % ein Buchstabe s steht, bei dem es sich um einen Typcode handelt, der zur Steuerung der Art der Datenanzeige verwendet wird. %s bedeutet, dass zuerst eine String-Typ-Position eingenommen wird.
Es gibt weitere gängige Typcodes, wie unten gezeigt:
Nachdem wir die Position besetzt haben, müssen wir den auszufüllenden Inhalt in der Form % eingeben, damit wir die Mühe der Typkonvertierung vermeiden können. Wenn mehrere Daten vorhanden sind, setzen Sie sie in Klammern, füllen Sie sie der Reihe nach und trennen Sie sie durch Kommas.
Sie können dies beispielsweise ausführen und die folgende Ausgabe vergleichen:
lucky = 8
print('我的幸运数字是%d' % lucky)
print('我的幸运数字是%d' % 8)
print('我的幸运数字是%s' % '小龙女的生日816')
print('我的幸运数字是%d和%d' % (8,16))
Operationsergebnis:
我的幸运数字是8
我的幸运数字是8
我的幸运数字是小龙女的生日816
我的幸运数字是8和16
Kleiner Tipp: Welcher Codetyp nach % verwendet werden soll, hängt davon ab, welchen Typ die Daten an der von % eingenommenen Position anzeigen sollen. Wenn Sie möchten, dass sie in Stringform angezeigt werden, schreiben Sie %s. Wenn Sie möchten Um als Ganzzahl angezeigt zu werden, schreiben Sie %d.
Dies führt zu Verwirrung. Führen Sie beispielsweise den folgenden Code aus:
print('我的幸运数字是%d' % 8) #8以整数展示
print('我的幸运数字是%s' % 8) #8以字符串展示
print(8) #整数8与字符串'8'打印出来的结果是一样的
print('8')
Operationsergebnis:
我的幸运数字是8
我的幸运数字是8
8
8
Es werden verschiedene Typcodes ausgewählt, aber die gedruckten Ergebnisse sind die gleichen. Der Grund wurde in den Codekommentaren klar angegeben: Da die gedruckten Ergebnisse der Ganzzahl 8 und der Zeichenfolge „8“ gleich sind, ist es in Ordnung, beide Typen auszuwählen Codes. . Diese „Alles OK“-Situation ist jedoch auf Ganzzahlen beschränkt und funktioniert nicht für Text, und es wird ein Fehler gemeldet.
Jetzt sollten Sie eine bessere Vorstellung davon haben, wie Sie diese Formatzeichenfolge verwenden.
Schauen wir uns noch einmal unseren vorherigen Code an. Wenn wir alle mit + am Anfang gespleißten Zeichenfolgen durch das %-Formatzeichen ersetzen, versuchen wir zunächst, einen Teil davon zu ersetzen.
print(' \n——————现在是第'+str(i)+'局——————') #替换前
print(' \n——————现在是第 %s 局——————' % i) #替换后
print('【玩家】\n'+'血量：'+str(player_life)+'\n攻击：'+str(player_attack)) #替换前
print('【玩家】\n血量：%s\n攻击：%s' % (player_life,player_attack)) #替换后
print('敌人发起了攻击，【玩家】剩余血量'+str(player_life)) #替换前
print('敌人发起了攻击，【玩家】剩余血量%s' % player_life) #替换后
Vielleicht möchten Sie mich fragen, ob %s hier durch %d ersetzt werden kann. Die Antwort lautet „JA!“, da die Variablen i, player_life und player_attack hier alle ganze Zahlen sind.
Okay, wählen wir dieses Mal die Verwendung von %s und schauen uns den vollständigen Code an:
import time
import random
player_victory = 0
enemy_victory = 0
for i in range(1,4):
time.sleep(1.5)
print(' \n——————现在是第 %s 局——————' % i)
#对比之前：(' \n——————现在是第'+str(i)+'局——————')
player_life = random.randint(100,150)
player_attack = random.randint(30,50)
enemy_life = random.randint(100,150)
enemy_attack = random.randint(30,50)
print('【玩家】\n血量：%s\n攻击：%s' % (player_life,player_attack))
print('------------------------')
time.sleep(1)
print('【敌人】\n血量：%s\n攻击：%s' % (enemy_life,enemy_attack))
print('-----------------------')
time.sleep(1)
while player_life > 0 and enemy_life > 0:
player_life = player_life - enemy_attack
enemy_life = enemy_life - player_attack
print('你发起了攻击，【敌人】剩余血量%s' % enemy_life)
print('敌人向你发起了攻击，【玩家】的血量剩余%s' % player_life)
print('-----------------------')
time.sleep(1.2)
if player_life > 0 and enemy_life <= 0:
player_victory += 1
print('敌人死翘翘了，你赢了！')
elif player_life <= 0 and enemy_life > 0:
enemy_victory += 1
print('悲催，敌人把你干掉了！')
else:
print('哎呀，你和敌人同归于尽了！')
if player_victory > enemy_victory :
time.sleep(1)
print('\n【最终结果：你赢了！】')
elif enemy_victory > player_victory:
print('\n【最终结果：你输了！】')
else:
print('\n【最终结果：平局！】')
Sieht es erfrischt aus? Es macht nichts, wenn Sie mit dieser Ausdrucksweise nicht vertraut sind. Der Lehrer wird sie in den folgenden Kursen vertiefen. Wenn Sie es ein paar Mal schreiben, werden Sie sich daran gewöhnen.
Jetzt verspreche ich, dass dies wirklich der letzte Schritt ist. Bitte führen Sie den folgenden Code direkt aus und spüren Sie die Ergebnisse unserer Reise.
import time
import random
player_victory = 0
enemy_victory = 0
for i in range(1,4):
time.sleep(1.5)
print(' \n——————现在是第 %s 局——————' % i)
player_life = random.randint(100,150)
player_attack = random.randint(30,50)
enemy_life = random.randint(100,150)
enemy_attack = random.randint(30,50)
print('【玩家】\n血量：%s\n攻击：%s' % (player_life,player_attack))
print('------------------------')
time.sleep(1)
print('【敌人】\n血量：%s\n攻击：%s' % (enemy_life,enemy_attack))
print('-----------------------')
time.sleep(1)
while player_life > 0 and enemy_life > 0:
player_life = player_life - enemy_attack
enemy_life = enemy_life - player_attack
print('你发起了攻击，【敌人】剩余血量%s' % enemy_life)
print('敌人向你发起了攻击，【玩家】的血量剩余%s' % player_life)
print('-----------------------')
time.sleep(1.2)
if player_life > 0 and enemy_life <= 0:
player_victory += 1
print('敌人死翘翘了，你赢了！')
elif player_life <= 0 and enemy_life > 0:
enemy_victory += 1
print('悲催，敌人把你干掉了！')
else:
print('哎呀，你和敌人同归于尽了！')
if player_victory > enemy_victory :
time.sleep(1)
print('\n【最终结果：你赢了！】')
elif enemy_victory > player_victory:
print('\n【最终结果：你输了！】')
else:
print('\n【最终结果：平局！】')
Das Obige ist unsere erste praktische Projektlektion. Wir verwenden hauptsächlich die Schleifenanweisungen und bedingten Beurteilungsanweisungen, die wir zuvor gelernt haben. Ich frage mich, ob Sie sich entspannt und glücklich fühlen, wenn Sie das sehen, und ein gewisses Erfolgserlebnis haben?
Wichtiger ist nicht, welche Projekte wir durchgeführt haben, sondern ob wir unser Wissen flexibel nutzen und die Methoden zur Projektdurchführung beherrschen können. Ich hoffe, dass es Ihnen beim Erlernen des Programmierens jetzt genauso geht wie mir.
Lassen Sie uns abschließend die drei Schritte zur Durchführung eines Projekts noch einmal durchgehen.
Wenn Schüler dieses Spiel eingehender erforschen und nach Perfektion streben möchten, können Sie diesen Artikel lesen: Implementierung des Minispiels „Word PK“ in Python (2)
Lassen Sie uns dieses Spiel optimieren und eine gute Zeit haben! ! !
Für die nächste Ebene werde ich versuchen, über „Programmierdenken“ zu sprechen, anstatt weiterhin so schnell über neues Wissen zu sprechen.
Ich hoffe, Sie an weitere Orte auf dem Weg des Lernens begleiten zu können und Ihnen eine breitere Perspektive zu ermöglichen.
Beim Programmierenlernen ergibt sich zweifellos eine breitere Perspektive aus den unterschiedlichen Denkweisen, die den Programmierkenntnissen zugrunde liegen.
Daher werde ich im nächsten Level einige Lösungen für die beiden größten Engpässe vorschlagen, auf die Schüler beim Erlernen von Python stoßen werden. Wir sehen uns im nächsten Level!