Python 3 ist auf Paiza völlig kostenlos, daher habe ich es zusammengefasst.
Einfach ausgedrückt, eine Reihe von Variablen und Funktionen
Spielerobjekt
--Variable
Name="paiza"
Beruf="Magier"
Körperliche Stärke="120"
--Funktion
Angriffsverarbeitung()
Verarbeitung verschieben()
In Objekten → Methoden organisierte Funktionen
--Erstellen und verwenden Sie Objekte aus Klassen --Klasse: Objektentwurfszeichnung --Object: Aus Klasse generieren
Spielerklasse
name
attack()
Erstellen Sie ein Player-Objekt aus der Player-Klasse
name="paiza"
attack()
name="python"
attack()
name="dragon"
attack()
Ein aus einer Klasse erstelltes Objekt wird als Instanz bezeichnet.
Schwer zu bekommende Fehler
Einfach wiederzuverwenden Einfach zu klassifizieren ↓ Zahlreiche Bibliotheken / Frameworks sind klassenbasiert
lesson.py
#Beginnen Sie den Klassennamen mit Großbuchstaben
#１.Geben Sie den Klassennamen Plyaer in der Klasse an
class Plyaer:
#2.Unterrichtsmethode(Schreiben Sie eine Funktion)
def walk(self):
print("Der Tapfere ging in der Wildnis spazieren")
#3.Erstellen Sie ein Objekt mit dem Klassennamen
#Weisen wir das erstellte Objekt einer Variablen zu
plyaer1=Plyaer()
#Variablennamen.Sie können das durch den Methodennamen erstellte Objekt auch aufrufen
plyaer1.walk()
#Sie können Variablen auch Objekte zuweisen
#Klasse
class Player:
#Eigenschaften und Methoden
def walk(self):
print("Der Tapfere ging in der Wildnis spazieren")
#Erhöhte Methoden
def attack(self, enemy):
print("Der Held" + enemy + "Angegriffen")
#Objekt
player1=Player()
player1.walk()
player1.attack("Schleim")
Der Tapfere ging in der Wildnis spazieren
Der Tapfere griff den Schleim an
#Ein Objekt ist eine Sammlung von Methoden und Eigenschaften einer Klasse.
lesson.py
class Greeting:
def say_hello(self):
print("hello paiza")
#Fügen Sie darunter den gewünschten Code hinzu
greeting=Greeting()
greeting.say_hello()
class Plyaer:
lesson.py
class Greeting:
#Fügen Sie darunter den gewünschten Code hinzu
def say_hello(self):
print("hello python")
paiza = Greeting()
paiza.say_hello()
Es gab keine:
lesson.py
class Greeting:
def say_hello(self):
print("hello paiza")
paiza = Greeting()
paiza.say_hello()
class Plyaer:
lesson.py
class Player:
#Konstrukteur
#Beim Erstellen eines Objekts aus einer Klasse
#Zuerst aufgerufene Methode
#Fügen Sie Plyaerclass eine Variable namens job hinzu
def __init__(self,job):
#Eine Instanzvariable aufgerufen
self.job=job
def walk(self):
print(self.job+"Ging in der Wildnis spazieren")
player1=Player("Krieger")
player1.walk()
player2=Player("Magier")
player2.walk()
#Das Objekt player1 hat weiterhin den Wert eines Kriegers
player1.walk()
Ausgabe
Der Krieger ging in der Wildnis spazieren
Die Hexe ging in der Wildnis spazieren
Der Krieger ging in der Wildnis spazieren
#self.Job ist eine Instanzvariable
#Eine Variable, die ein Objekt hat
#Instanzvariablen sind so lange vorhanden, wie das Objekt vorhanden ist
#Der Wert wird gespeichert
self.job=job
#Was ist Selbst
#Bei Verwendung von Instanzvariablen erforderliche Argumente
#In Python ist dies das erste Argument der Methode in der Klasse
#Das zum Aufrufen der Methode verwendete Objekt selbst wird übergeben
#Selbst ist Englisch und bedeutet mich selbst,
#Bezieht sich auf das Objekt, mit dem die Methode aufgerufen wird
#Wenn Sie die Arbeitsmethode von player1 aufrufen, Selfjob
#Rufen Sie die Jobvariable von player1 auf
#Wenn Sie die Arbeitsmethode von player2 aufrufen
#Aufruf der Jobvariablen von player2
def __init__(self,job):
lesson.py
#Lassen Sie uns ein Objekt aus einer Klasse erstellen
class Greeting:
def __init__(self, name):
self.name = name
def say_hello(self):
print("hello " + self.name)
#Beschreiben Sie unten die notwendige Verarbeitung
greeting=Greeting("paiza")
greeting.say_hello()
Ausgabe
hello paiza
lesson.py
class Greeting:
def __init__(self,name):
self.name=name
def say_hello(self):
print("hello " + self.name)
paiza = Greeting("paiza")
paiza.say_hello()
hello paiza
lesson.py
class Greeting:
def __init__(self, name):
self.name = name
def say_hello(self):
print("hello " + self.name)
paiza = Greeting("paiza")
paiza.say_hello()
class Plyaer:
lesson.py
Rezension
def attack(enemy):
print(enemy + "Hat die Tapferen angegriffen")
attack("Schleim")
'''
Bilden Sie eine feindliche Klasse
class Enemy:
def__init__(self,name)
self.name=name
'''
#Bilden Sie eine feindliche Klasse
'''
class Enemy:
def__init__(self,name)
self.name=name
'''
class Enemy:
def __init__(self,name):
self.name = name
def attack(self):
#enemy→self.nane
print(self.name + "Hat die Tapferen angegriffen")
#Erstellen Sie ein Objekt aus der feindlichen Klasse
slime=Enemy("Schleim")
slime.attack()
Ausgabe
Schleim griff den Mutigen an
lesson.py
#Bilden Sie eine feindliche Klasse
class Enemy:
def __init__(self,name):
self.name = name
def attack(self):
print(self.name + "Hat die Tapferen angegriffen")
#In einer Liste zusammenstellen, um mehrere Feinde zu erstellen
enemies=[]
enemies.append(Enemy("Schleim"))
enemies.append(Enemy("Monster-"))
enemies.append(Enemy("Drachen"))
#Verwenden Sie die Anweisung für die Ausgabe
for enemy in enemies:
enemy.attack()
Ausgabe
Schleim griff den Mutigen an
Das Monster hat den Helden angegriffen
Der Drache griff den Helden an
#Englischunterricht hat die Bedeutung von Klassifizierung
#Schleim, Monster und Drache sind Feinde derselben feindlichen Klasse, sodass Sie die übliche Angriffsmethode verwenden können.
#Die englische Instanz hat die Bedeutung eines Beispiels
#Die feindliche Klasse definiert die Klassifizierung des Feindes und erzeugt Schleim und Monster als Objekte.
#Die erstellte Liste wird der Feindeliste mit der for-Anweisung zugewiesen.
RPG-Angriffsszene
lesson.py
class Player:
def __init__(self, name):
self.name = name
def attack(self, enemy):
print(self.name + "Ist" + enemy + "Angegriffen")
team = []
team.append(Player("Mutig"))
team.append(Player("Krieger"))
team.append(Player("Magier"))
for player in team:
player.attack("Schleim")
lesson.py
class Item:
def __init__(self,price,quantity):
self.price=price
self.quantity=quantity
def total(self):
return self.price * self.quantity
apple=Item(120,15)
print("Der Gesamtbetrag beträgt" + str(apple.total()) + "Es ist ein Kreis")
#total=apple.total(),str(total)
#Auch wenn es OK ist → Der Rückgabewert der Gesamtmethode wird per Druck ausgegeben
apple=Item(120,15)
print("Der Gesamtbetrag beträgt" + str(total) + "Es ist ein Kreis")
orange=Item(85,32)
print("Der Gesamtbetrag beträgt"+str(orange.total())+"Es ist ein Kreis")
Ausgabe
Der Gesamtbetrag beträgt 1800 Yen
Der Gesamtbetrag beträgt 1800 Yen
Der Gesamtbetrag beträgt 2720 Yen
lesson.py
Wie macht man den Betrag inklusive Steuern?
class Item:
tax=1.08
#Verwenden Sie die Klassenvariable, für die Sie eine Verbrauchssteuer erstellen möchten.
#Im Gegensatz zu Instanzvariablen aus dieser Klasse erstellt
#Variablen, die in allen Objekten verwendet werden können
def __init__(self,price,quantity):
self.price=price
self.quantity=quantity
def total(self):
#Int nach dem Dezimalpunkt abschneiden
#Zur Berechnung der Verbrauchsteuer`Item.tax
return int(self.price * self.quantity*Item.tax)
apple=Item(120,15)
total=apple.total()
print("Der Gesamtbetrag beträgt" + str(total) + "Es ist ein Kreis")
orange=Item(85,32)
print("Der Gesamtbetrag beträgt"+str(orange.total())+"Es ist ein Kreis")
Der Gesamtbetrag beträgt 1944 Yen
Der Gesamtbetrag beträgt 2937 Yen
lesson.py
class Gakusei:
def __init__(self, kokugo, sansu):
self.kokugo = kokugo
self.sansu = sansu
def sum(self):
return str(self.kokugo + self.sansu)
#Beschreiben Sie unten die notwendige Verarbeitung
yamada = Gakusei(70, 43)
print("Die Summe ist" +str(yamada.sum()) +"Ist ein Punkt")
lesson.py
class Gakusei:
def __init__(self, kokugo, sansu):
self.kokugo = kokugo
self.sansu = sansu
#Beschreiben Sie darunter die Summenmethode, die die Gesamtpunktzahl als Rückgabewert zurückgibt.
def sum(self):
return str(self.kokugo + self.sansu)
yamada = Gakusei(70, 43)
print("Die Summe ist" + str(yamada.sum()) + "Ist ein Punkt")
lesson.py
text= "pYthon"
print(text)
#Großschreiben Sie das Akronym
print(text.capitalize())
#Alles Kapital
print(text.upper())
players="Mutig,Krieger,Magier,Ninja"
#Listen Sie Zeichenfolgen auf
#Die Split-Methode ist das durch das Argument angegebene Zeichen
#Eine Methode, die eine Zeichenfolge aufteilt und eine Liste zurückgibt
list=players.split(",")
print(list)
#In der Liste verfügbare Methoden
#Das durch das Argument angegebene Element kann aus der Liste gelöscht werden
list.remove("Ninja")
print(list)
list.append("Kirishima")
print(list)
pYthon
Python
PYTHON
['Mutig', 'Krieger', 'Magier', 'Ninja']
['Mutig', 'Krieger', 'Magier']
['Mutig', 'Krieger', 'Magier', 'Kirishima']
lesson.py
Eingang
testcase
msg = input()
#Beschreiben Sie unten den Vorgang, um anzuzeigen, ob msg nur in Kleinbuchstaben geschrieben ist.
print(msg.islower())
Ausgabe
True
lesson.py
team = ["Mutig", "Krieger", "Magier", "Ninja"]
#Fügen Sie darunter "Dieb" zu Index 3 hinzu und beschreiben Sie den Vorgang zum Anzeigen der Liste
team.insert(3, "Diebe")
print(team)
lesson.py
class Player:
def __init__(self, job, weapon):
self.job = job
self.weapon = weapon
def walk(self):
print(self.job + "Ging in der Wildnis spazieren")
#Stellen Sie dem Methodennamen einen Unterstrich voran
#__attack
def __attack(self, enemy):
print(self.weapon + "damit" + enemy + "Angreifen")
#__attack
self.__attack("Schleim")
player1 = Player("Krieger", "Schwert")
player1.walk()
#__Sie können dies nicht außerhalb der Angriffsklasse tun
#player1.__attack("Schleim")
__.weapon
print(player1.weapon)
#Unterstrich vor Variablenname(__)Wenn Sie zwei hinzufügen
#Werden Sie zu einer Variablen, die nur in der Klasse aufgerufen werden kann
#Dies wird als private Variable oder Privateigenschaft bezeichnet.
lesson.py
class Player:
def __init__(self, job, weapon):
self.job = job
#__weapon
self.__weapon = weapon
def walk(self):
print(self.job + "Ging in der Wildnis spazieren")
def __attack(self, enemy):
#__weapon
print(self.__weapon + "damit" + enemy + "Angreifen")
self.__attack("Schleim")
player1 = Player("Krieger", "Schwert")
player1.walk()
#__weapon
print(player1.__weapon)
#Unterstrich vor Variablenname(__)Wenn Sie zwei hinzufügen
#Werden Sie zu einer Variablen, die nur in der Klasse aufgerufen werden kann
#Dies wird als private Variable oder Privateigenschaft bezeichnet.
"Eine Methode für eine Zeichenfolge ausführen"
lesson.py
class Greeting:
def __init__(self, name):
self.__name = name
def say_hello(self):
#Fügen Sie hier zwei Unterleisten hinzu
print("hello " + self.__name)
paiza = Greeting("paiza")
paiza.say_hello()
Recommended Posts