Udemy Anwesenheitsliste der folgenden Kurse
Kurs zur Entwicklung von Webanwendungen mit Python + Flask! !! ~ Master Flask von 0 zum Erstellen von SNS ~ https://www.udemy.com/course/flaskpythonweb/
Die grundlegende Grammatik von Python und die Anwendungserstellung mit Flask werden separat beschrieben.
Erstellen Sie eine virtuelle Umgebung zum Erstellen von Anwendungen mit venv.
(base) root@e8cf64ce12e9:/home/venv/flaskenv# python -m venv flaskenv
-Der Name der virtuellen Umgebung, die gestartet wurde, wird mit () am Zeilenanfang angezeigt.
(base) root@e8cf64ce12e9:/home/venv/flaskenv# source bin/activate
(flaskenv) (base) root@e8cf64ce12e9:/home/venv/flaskenv#
·Halt
(flaskenv) (base) root@e8cf64ce12e9:/home/venv/flaskenv# deactivate
(base) root@e8cf64ce12e9:/home/venv/flaskenv#
Kürzung
kekosh@kekosh-mbp flaskenv % git init
Initialized empty Git repository in /Users/kekosh/work/docker/venv/flaskenv/.git/
kekosh@kekosh-mbp flaskenv % git add .
kekosh@kekosh-mbp flaskenv % git commit -m 'first commit'
kekosh@kekosh-mbp flaskenv % git remote add origin [email protected]:kekosh/flask-sns.git
kekosh@kekosh-mbp flaskenv % git push -u origin master
kekosh@kekosh-mbp flaskenv % git remote rm origin
Für Mac wird in jedem Verzeichnis eine versteckte Datei mit dem Namen ".DS_Store" erstellt. Da dies keine Datei ist, die von Git verwaltet werden sollte, registrieren Sie sie vor dem Festschreiben als nicht verwaltet in gitignore.
.gitignore
# Mac
.DS_Store
Wenn Sie bereits eine Verknüpfung zu Github hergestellt haben, löschen Sie den Git-Cache, nachdem Sie das oben Gesagte zu .gitignore hinzugefügt haben. Machen Sie es ab dem nächsten Commit nicht mehr verwaltet.
kekosh@kekosh-mbp flaskenv % git rm -r --cached .
Python
Nimmt eine Sammlung mehrerer Vergleichsbedingungen als Tupel als Argument. Gibt True zurück, wenn alle bedingten Ausdrücke True sind
>>> i = 0
>>> x = 'test'
>>> if all((i<10, x =='test')):
... print('Alles wahr')
...
Alles wahr
Nimmt eine Sammlung mehrerer Vergleichsbedingungen als Tupel als Argument. Gibt True zurück, wenn einer der bedingten Ausdrücke True ist.
>>> i = 0
>>> x = 'any'
>>> if any((i > 10, x == 'any' )):
... print('Einschließlich True')
...
Einschließlich True
>>> list = ['taro','jiro','sabu','shiro']
>>> for i, v in enumerate(list):
... print(i, v)
...
0 taro
1 jiro
2 sabu
3 shiro
>>> list_a = ['cat','dog','rabbit']
>>> list_b = ['mike','jhon','usa']
>>> for a, b in zip(list_a,list_b):
... print(a, b)
...
cat mike
dog jhon
rabbit usa
Kürzung
m = 100
n = input()
try:
result = m /int(n)
print(result)
except ZeroDivisionError as ze:
import traceback
traceback.print_exc()
print('end')
#Ergebnis
kekosh-mbp:flaskenv kekosh$ python main.py
0
Traceback (most recent call last):
File "main.py", line 5, in <module>
result = m /int(n)
ZeroDivisionError: division by zero
end
try ~ except ~ else ~ finally
--other: Prozess wird nur ausgeführt, wenn kein Fehler auftritt. Die hier auftretende Ausnahme wird von der vorherigen Ausnahme nicht erfasst. --finally: Prozess, der immer ausgeführt wird, unabhängig davon, ob ein Fehler vorliegt oder nicht.
try:
#Hauptverarbeitung
except XXXXXX as e:
#Prozess, der ausgeführt werden soll, wenn eine bestimmte Ausnahme auftritt
except Exception e:
#Verarbeitung, wenn alle Ausnahmen auftreten, mit Ausnahme von Ausnahmen, die eine bestimmte Verarbeitung beschreiben
else:
#Verarbeitung, die nur ausgeführt wird, wenn keine Ausnahme auftritt
finally:
#Verarbeitung, die unabhängig vom Vorhandensein oder Fehlen von Ausnahmen immer ausgeführt wird
raise ZeroDivisionError('Nicht durch Null teilbar')
Erstellen Sie eine Klasse, die die Exception-Klasse erbt.
#Vorlage
class MyException(Exception)
print('Es ist ein proprietärer Fehler aufgetreten')
#Implementierungsbeispiel
class EvenDevideError(Exception):
pass
def main():
m = 10
n = int(input('Eingang:'))
if n == 2:
raise EvenDevideError('even number input')
else:
print('end')
if __name__ == '__main__':
main()
#Ergebnis
kekosh-mbp:flaskenv kekosh$ python main.py
Eingabe: 2
Traceback (most recent call last):
File "main.py", line 14, in <module>
main()
File "main.py", line 9, in main
raise EvenDevideError('even number input')
__main__.EvenDevideError: even number input
>>> def func_1(arg1, *arg2):
... print("arg1={}, *arg2={}".format(arg1, arg2))
...
>>> def func_2(arg1, **arg2):
... print("arg1={}, **arg2={}".format(arg1, arg2))
#Wenn Sie mehrere Werte übergeben"*"Stellen Sie die Werte einzeln von vorne auf die Variablen ohne ein
#Die verbleibenden Argumentwerte werden in arg2 gemeinsam als Taple festgelegt.
>>> func_1(1,2,3,4,5)
arg1=1, *arg2=(2, 3, 4, 5)
#"**"Im Fall von, wenn ein Wert übergeben wird, wie eine Variable vom Typ Wörterbuch"id=1"In einem Format wie
#Sie müssen das Argument festlegen.
>>> func_2(1,2,3,4,5)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: func_2() takes 1 positional argument but 5 were given
>>>
>>> func_2(1, id=1, name='taro')
arg1=1, **arg2={'id': 1, 'name': 'taro'}
def generater(max):
print('Generator generieren')
for i in range(max):
#Die Verarbeitung stoppt beim Erstellen einer Instanz bei Yield und die Yield-Variable wird an den Aufrufer zurückgegeben.
yield i
print('Ertragsausführung')
gen = generater(10)
#next()Durch Übergeben der Generatorfunktion an wird die Verarbeitung nach Ausbeute ausgeführt.
n = next(gen)
print('n = {}'.format(n))
n = next(gen)
print('n = {}'.format(n))
#next()Es ist auch möglich, stattdessen durch Schleifenverarbeitung auszuführen
for x in generater(10):
print('x = {}'.format(x))
Generator generieren
n = 0
Ertragsausführung
n = 1
def gengerator(max)
#Kürzung
for i in generator()
x = yield i
print(x)
gen = generator(10)
#Senden Sie nach Beendigung der Behandlung mit Ertrag an die Variable, in der der Ertrag gespeichert ist(val)Speichern Sie den Wert von.
gen.send(100)
--generator.throw (err_value): Erzeugt absichtlich einen Fehler. --generator.close (): Ende der Ertragsverarbeitung
--Ertrag vom Untergenerator: Eine andere Generatorfunktion kann von der Generatorfunktion aufgerufen werden.
def sub_gen():
yield 'sub_generator'
print('on sub_gen')
return 'sub_gen'
def main_gen():
yield 'main_generator'
#Rufen Sie den Subgenerator mit Ausbeute von auf
res = yield from sub_gen()
print(res)
return 'main_gen'
gen = main_gen()
print(next(gen))
print(next(gen))
print(next(gen))
main_generator
sub_generator
on sub_gen
sub_gen
Traceback (most recent call last):
File "d:/MyFile/arc/pyenv/py-outlook/app.py", line 17, in <module>
print(next(gen))
StopIteration: main_gen
def print_hello(func):
print('hello')
func('taro')
return print_message
def print_bye(name='someone'):
print('good bye, {}'.format(name))
def print_message():
print('Der Rückgabewert ist eine Funktion')
#pattern1.Speichern Sie die Funktion als Listenelement
list = [1, 'test', print_bye, print_hello]
#pattern1.Bei der Ausführung von Funktionen höherer Ordnung "" nach dem Index()""
list[2]()
#pattern2.Muster zum Übergeben der Funktion an das Argument der Funktion (der Rückgabewert ist auch eine Funktion)
var = print_hello(print_bye)
var()
#Ergebnis von Muster1
good bye, someone
#Ergebnis von pattern2
hello
good bye, taro
Der Rückgabewert ist eine Funktion
#Lambda-Ausdruck in der if-Anweisung
def func(x):
response = ''
#Normale if-Anweisung
if x > 5:
response = 'large'
else:
response = 'small'
return response
#Lambda-Format
response = 'large' if x > 5 else 'small'
return response
x = int(input('Eingang:'))
res = func(x)
print(res)
>>> func = lambda x,y,z : x*y*z if z > 10 else x*y
>>>
>>> func(1,2,3)
2
>>> func(1,2,15)
30
--Um die Funktion selbst innerhalb der Funktion auszuführen.
>>> def fib(n):
... n = int(n)
... return n if n <= 2 else fib(n-1) + fib(n-2)
>>> for i in range(1,10):
... print(fib(i))
...
1
2
3
5
8
13
21
34
55
--Variable name = [Ausdruck für Variable in Liste (wenn Ausdruck)]
#Listeneinschlussnotation zum Erstellen einer Liste
>>> list_a = [x * 2 for x in range(1,10)]
>>> print(list_a)
[2, 4, 6, 8, 10, 12, 14, 16, 18]
>>>
>>> list_b = [x * 2 for x in range(1,10) if x % 2 == 0]
>>> print(list_b)
[4, 8, 12, 16]
#Listeneinschlussnotation der Tapple-Erstellung
>>> list_c = tuple(x for x in range(10))
>>> list_c
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
>>> type(list_c)
<class 'tuple'>
#Dekorationsfunktion definieren
def decorator(func):
def wrapper(*args, **kwargs):
print('*' * 30)
#Argument: func wird auf ein Funktionsobjekt mit einem Dekoratorsatz gesetzt.
func(*args, **kwargs)
print('*' * 30)
return wrapper
#Die Funktion mit dem Dekorator im Argument der Dekoratorfunktion wird gesetzt und ausgeführt.
@decorator
def func_a(*args, **kwargs):
print('func_Führen Sie a')
print(args)
@decorator
def func_b(*args, **kwargs):
print('func_Führen Sie b aus')
print(kwargs)
func_a(1,2,3)
func_b(4,5,6,id=4,name='test')
kekosh-mbp:flaskenv kekosh$ python decorator.py
******************************
func_Führen Sie a
(1, 2, 3)
******************************
******************************
func_Führen Sie b aus
{'id': 4, 'name': 'test'}
******************************
--map ([Funktion], [an Funktion übergebene Variablen] ...)
#Typisches Beispiel: Listentyp als zweites Argument
list_a = [1,2,3,4,5]
map_a = map(lambda x: x*2, list_a)
#Überprüfen Sie den Inhalt des Map-Typ-Objekts mit der for-Anweisung
for x in map_a:
print(x)
#Wörterbuchargumente können ebenfalls verwendet werden
person = {
'name': 'Yamada'
,'age': '34'
,'country': 'Japan'
}
#Der Funktionsteil kann auch den Lambda-Ausdruck beschreiben
map_b = map(lambda d : d+ ',' + person.get(d), person)
for m in map_b:
print(m)
'''
Wenn mehrere Argumente an eine Funktion übergeben werden, werden zwischen den Iteratorausdrucksvariablen Variablen an die Funktion des ersten Arguments übergeben
Wenn die Anzahl der Elemente unterschiedlich ist, schneiden Sie entsprechend der Anzahl der Elemente zu viel ab.
'''
list_x = ['apple','grape','lemon','peach']
dic_x = {'apple':'150','grape':'140','lemon':'110','peach':'180'}
tuple_x = tuple(x for x in range(1,5))
def mapping(name,dic,count):
fruit = name
price = dic_x.get(fruit)
return fruit + ':' + str(price) + ':' + str(count)
map_c = map(mapping,list_x,dic_x,tuple_x)
for mc in map_c:
print(mc)
2
4
6
8
10
name,Yamada
age,34
country,Japan
apple:150:1
grape:140:2
lemon:110:3
peach:180:4
#Klassendefinitionsvorlage
class className:
"""Kommentare, die die Funktion der Klasse erklären"""
def methodName(self,...):
#wird bearbeitet
#Erstellen Sie eine Instanz, um die definierte Klasse zu verwenden
instance = className()
#<Stichprobe>
#Klassendefinition
class Car:
country = 'japan'
year = 2020
name = 'Prius'
#Stellen Sie beim Definieren einer Methode in einer Klasse sicher, dass das erste Argument der Methode "self" ist.
def print_name(self):
print('Methodenausführung')
print(self.name)
my_Car = Car()
print(my_Car.year)
my_Car.print_name()
#Verwenden Sie eine Klasse (Instanz) für ein Element vom Listentyp
list = ['apple', 'banana', Car()]
list[2].print_name()
** Klassenvariablen ** --Variablen, die von Objekten gemeinsam genutzt werden können --Liste direkt unter der Klasse
** wie man darauf zugreift ** --Klassenname. Name der Klassenvariablen --Instanzname. \ _ \ _ Klasse__. Klassenvariable ** * Wenn \ _ \ _ class \ _ \ _ nicht beschrieben wird (Instanzname.Klassenname), unterscheiden sich die Daten, die erfasst werden können, von der Klassenvariablen (Instanzvariable wird erfasst) **
Instanzvariable --Variationen werden für jede Instanz separat verwendet
** wie man darauf zugreift ** Instanzname.Variable
class SampleA():
#Klassenvariable
class_val = 'class val'
def set_val(self):
#Instanzvariable
self.instance_val = 'instance val'
def print_val(self):
print('Klassenvariable:{}'.format(self.class_val))
print('Instanzvariable:{}'.format(self.instance_val))
#Instanzerstellung
instance_A = SampleA()
#Aufruf der Instanzmethode
instance_A.set_val()
print(instance_A.instance_val)
instance_A.print_val()
#Ausgabe von Klassenvariablen
print(SampleA.class_val)
print(instance_A.__class__.class_val)
print('---------------------')
#Erstellen Sie eine neue Instanz aus der Klasse
instance_B = SampleA()
instance_B.class_val = 'change'
#Wenn Sie den Wert einer Klassenvariablen aus einer Instanz ändern, auch wenn Sie auf die Klassenvariable aus einer anderen Instanz verweisen
#Beachten Sie, dass sich der Wert ändert.
print('instance_Klassenvariable von A:{}'.format(instance_A.__class__.class_val))
print('instance_Variable der Klasse B:{}'.format(instance_B.__class__.class_val))
instance val
Klassenvariable: Klasse val
Instanzvariable= instance val
class val
class val
---------------------
instance_Klassenvariable von A: Klasse val
instance_B Klassenvariable: Klasse val
kekosh-mbp:flaskenv kekosh$
class Sample:
#Konstrukteur
def __init__(self, msg, name=None):
print('Konstruktorausführung')
#Weisen Sie der Instanzvariablen den Wert des Arguments zu
self.msg = msg
self.name = name
def print_msg(self):
print(self.msg)
def print_name(self):
print(self.name)
inst_1 = Sample('hello', 'taro')
inst_1.print_msg()
inst_1.print_name()
#Der Konstruktor wird beim Erstellen der Instanz automatisch ausgeführt.
Konstruktorausführung
hello
taro
--Prozess, der aufgerufen wird, wenn die Instanz gelöscht wird (am Ende der Verwendung)
#Zerstörer
def __del__(self):
print('Destruktor lief')
print('name = {}'.format(self.name))
#Am Ende der Instanzverarbeitung (auch beim Löschen durch den Namen der Löschinstanz)
Destruktor lief
name = taro
** Instanzmethode **
** Klassenmethode ** Eine Methode, die ohne Instanziierung verwendet werden kann. Schreiben Sie "@classmethod" direkt über die Methodendefinition und setzen Sie das erste Argument auf "cls". --Class-Methode kann mit class name.class method name () ausgeführt werden. --cls bedeutet Klasse selbst --Cls. Sie können mit dem Namen der Klassenvariablen auf Klassenvariablen zugreifen.
** Statische Methode ** --Schreiben Sie "@staticmethod" direkt über die Methodendefinition.
class Human:
class_name='Human'
#Konstrukteur
def __init__(self, name, age):
self.name = name
self.age = age
#Instanzmethode
def print_name_Age(self):
print('Ausführung der Instanzmethode')
print('name={}, age={}'.format(self.name, self.age))
#Klassenmethode
@classmethod
def print_class_name(cls, msg):
print('Ausführung der Klassenmethode')
print(cls.class_name)
print(msg)
#Statische Methode
@staticmethod
def print_msg(msg):
print('Statische Methodenausführung')
print(msg)
#Klassenmethode
Human.print_class_name('Hallo')
#Instanzmethode
human =Human('taro', 18)
human.print_name_Age()
#Statische Methode
human.print_msg('statisch')
Ausführung der Klassenmethode
Human
Hallo
Ausführung der Instanzmethode
name=taro, age=18
Statische Methodenausführung
statisch
Eine Methode, die aufgerufen wird, wenn Sie beim Zugriff auf eine Instanz eine bestimmte Operation ausführen
| Methode | Überblick |
|---|---|
| __str__(self) | str(),print()Wird beim Ausführen aufgerufen und gibt eine Zeichenfolge zurück |
| __bool__(self) | Passen Sie den Vergleichsprozess der if-Anweisung an |
| __len__(self) | len()Passen Sie den Verarbeitungsinhalt von an |
| __eq__(self、other) | Für die Instanz==Wird bei Verwendung eines Operators aufgerufen |
| __name__(self) | Gibt den Namen der Klasse zurück |
| __hash__(self) | Erstellt einen Hash-Wert und gibt ihn aus dem übergebenen Wert zurück |
Referenz
--Offizielles Dokument https://docs.python.org/ja/3.6/reference/datamodel.html#special-method-names
#Spezielle Methode
class Human:
#Konstrukteur
def __init__(self, name, age, phone):
self.name = name
self.age = age
self.phone = phone
#Spezielle Methode: Drucken()Gibt das folgende Verarbeitungsergebnis zurück, wenn
def __str__(self):
return self.name + ":" + str(self.age)
#Spezielle Methode: "==Passen Sie den Inhalt des Vergleichsprozesses an
"""
Wenn beim Vergleich von Instanzen Name und Telefon übereinstimmen, auch wenn das Alter unterschiedlich ist
Gibt True zurück.
"""
def __eq__(self, args):
return (self.name == args.name) and (self.phone == args.phone)
man = Human('tanaka', 18, '090-9999-8888')
print(man)
woman = Human('tanaka', 20, '090-9999-8888')
print(man == woman)
#__str__Ergebnis von
tanaka:18
#__eq__Wenn Sie nicht definiert haben
False
#__eq__Wenn Sie definiert haben
True
#Einzigartige Ausnahme
class CharaterAlreadyExistsException(Exception):
pass
class AllCharacters:
'''
Zeicheninformationsverwaltungsklasse
'''
all_characters = []
alive_characters = []
dead_characters = []
@classmethod
def character_append(cls,name):
#Der gleiche Name gibt einen eindeutigen Fehler zurück
if name in cls.all_characters:
raise CharaterAlreadyExistsException('Vorhandener Charaktername')
cls.all_characters.append(name)
cls.alive_characters.append(name)
@classmethod
def character_delete(cls,name):
cls.dead_characters.append(name)
cls.alive_characters.remove(name)
class Character:
def __init__(self,name,hp,offense,defense):
#Registrieren Sie Zeicheninformationen im Konstruktor, wenn Sie eine Instanz erstellen
AllCharacters.character_append(name)
self.name = name
self.hp = hp
self.offense = offense
self.defense = defense
def attack(self,enemy,critical=1):
if self.hp <= 0:
print('Character is Already dead.')
return
attack = self.offense - enemy.defense
attack = 1 if attack <= 0 else attack
enemy.hp -= (attack * critical)
if enemy.hp <= 0:
AllCharacters.character_delete(enemy.name)
def critical(self, enemy):
self.attack(enemy,2)
#----Anwendungsausführung-----
chara_A = Character('A',10,5,3)
chara_B = Character('B',8,6,2)
print(chara_B.hp)
#chara_A.attack(chara_B)
chara_A.critical(chara_B)
print(chara_B.hp)
print(AllCharacters.alive_characters)
chara_A.critical(chara_B)
print(AllCharacters.dead_characters)
print(AllCharacters.alive_characters)
chara_B.attack(chara_A)
#Ausführungsergebnis
8
2
['A', 'B']
['B']
['A']
Character is Already dead.
** Vererbung **
** Polymorphismus ** --Erstellen Sie mehrere Unterklassen mit demselben Namen, aber unterschiedlichen Verarbeitungsinhalten.
** überschreiben **
Überlast
#Übergeordnete Klasse
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def greeting(self):
print('hello, {}'.format(self.name))
def say_age(self):
print('{} years old.'.format(self.age))
#Erben Sie die Person-Klasse
class Employee(Person):
def __init__(self, name, age, number):
#super()Verwenden Sie diese Option, um den Konstruktor der übergeordneten Klasse aufzurufen.
super().__init__(name, age)
#Da die Werte der folgenden Eigenschaften im Konstruktoraufruf der übergeordneten Klasse festgelegt werden,
#Die Zuordnung der Unterklasse zur Eigenschaft ist optional
# self.name = name
# self.age = age
#Da number ein eindeutiges Element der Employee-Klasse ist, wird es separat zugewiesen.
self.number = number
def say_number(self):
print('my number is {}'.format(self.number))
#Überschreiben Sie übergeordnete Klassenmethoden
def greeting(self):
#Führen Sie die gleichnamige Methode in der übergeordneten Klasse aus
super().greeting()
print('I\'m employee number = {}'.format(self.number))
#Überlast(Eine Funktion, die in Python nicht gefunden wurde. Das Standardargument kann ersetzt werden)
# def greeting(self, age=None):
# print('Überlast')
man = Employee('Tanaka', 34, 12345)
man.greeting()
man.say_age()
hello, Tanaka
I'm employee number = 12345
34 years old.
** Mehrfachvererbung ** Mehrere Klassen können als übergeordnete Klassen vererbt werden.
class Class_A:
def __init__(self, name):
self.a_name = name
def print_a(self):
print('ClassA method running')
print('a = {}'.format(self.a_name))
def print_hi(self):
print('{}, hi'.format(self.name))
class Class_B:
def __init__(self, name):
self.b_name = name
def print_b(self):
print('ClassB method running')
print('b = {}'.format(self.b_name))
def print_hi(self):
print('{}, Hi!'.format(self.b_name))
#Mehrere geerbte Unterklassen
class NewClass(Class_A, Class_B):
def __init__(self, a_name, b_name, name):
Class_A.__init__(self, a_name)
Class_B.__init__(self, b_name)
self.name = name
def print_new_name(self):
print("name = {}".format(self.name))
def print_hi(self):
Class_A.print_hi(self)
Class_B.print_hi(self)
print('New Class hi')
sample = NewClass('A_Name','B_Name','New Class Name',)
#Führen Sie die geerbten Methoden ClassA und ClassB aus
sample.print_a()
sample.print_b()
#Führen Sie unterklassenspezifische Methoden aus
sample.print_new_name()
#Führen Sie die Oberklassenmethode aus der Unterklasse aus
sample.print_hi()
ClassA method running
a = A_Name
ClassB method running
b = B_Name
name = New Class Name
New Class Name, hi
B_Name, Hi!
New Class hi
Ist beim Erstellen mehrerer Unterklassen die Methode mit demselben Namen immer definiert und kann ausgeführt werden?
** Abstrakte Klasse **
#Abstrakte Klassenvorlage
from abc import ABCMeta, abstractmethod
class Human(metaclass=ABCMeta)
@abstractmethod
def say_name(self, name):
pass
** abstrakte Methode **
#Abstrakte Klasse
from abc import ABCMeta, abstractmethod
class Human(metaclass = ABCMeta):
def __init__(self, name):
self.name = name
#Abstrakte Methode
@abstractmethod
def say_something(self):
pass
def say_name(self):
print('my name is {}.'.format(self.name))
"""
Wenn Sie die abstrakte Klasse wie folgt erben@Als abstrakte Methode deklariert
Wenn Sie die Methode nicht überschreiben, tritt beim Erstellen der Instanz ein Fehler auf.
class Woman(Human):
pass
Error:
TypeError: Can't instantiate abstract class Woman with abstract methods say_something
"""
class Woman(Human):
def say_something(self):
print('I\'m Lady.')
class Man(Human):
#Argumenttyp mit Überschreibung hinzufügen
def say_something(self, name='nameless', age='20'):
print('I\'m Men.' + str(age))
#Abstrakte Klassenausführung
# wm = Woman('Hanako')
# me = Man("Yamada")
# wm.say_something()
# me.say_something('taro',12)
#Polymorphismus
"""
Bis zur Ausführung wird nicht entschieden, ob es sich um einen Mann oder eine Frau handelt.
Es spielt keine Rolle, ob die auszuführende Instanzmethode eine Instanz einer der Klassen ist
Kann ausgeführt werden
"""
num = input('Please input 0 or 1: ')
human = ""
if num == '0':
human = Woman(Human)
elif num == '1':
human = Man(Human)
else:
print('wrong number')
human.say_something()
--Überprüfen Sie das Ausführungsergebnis der abstrakten Klasse--
I'm Lady.
I'm Men.12
#Wenn Sie 0 eingeben
--Ergebnis der Ausführung des Polymorphismus--
I'm Lady.
#Wenn Sie 1 eingeben
--Ergebnis der Ausführung des Polymorphismus--
I'm Men.20
--Variationen, auf die von außen nicht zugegriffen werden kann (Es gibt eine Möglichkeit, in Python darauf zuzugreifen)
__variable = "val"
#Beim Versuch, eine private Variable aufzurufen
AttributeError: 'Human' object has no attribute '__name'
#Greifen Sie von einer Instanz aus auf private Variablen zu
val =Beispiel._Name der Klasse__name
Bei Verwendung von privaten Variablen müssen die privaten Variablen gekapselt werden, damit sie nicht von außerhalb der Klasse angezeigt werden können.
#Getter Definition
def get_Variablennamen()：
wird bearbeitet
#Definition des Setzers
def set_Variablennamen();
wird bearbeitet
#getter,Erstellen Sie eine Eigenschaft, um den Setter aufzurufen
Variablennamen= property(get_Variablennamen, set_Variablennamen)
** <Muster 1> **
#Verkapselung, Getter, Setter-Muster 1
class Human:
def __init__(self,name,age):
#private Variable
self.__name = name
self.__age = age
def get_name(self, name):
print('call getter [name]')
return self.__name
def set_name(self, name):
print('call setter [name]')
self.__name = name
#Erstellen einer Eigenschaft (Getter,Erforderlich, um Setter zu verwenden)
#Verwenden Sie die Eigenschaft, wenn Sie von außen darauf zugreifen.
name = property(get_name, set_name)
def print_name(self):
print(self.__name)
human = Human('Tanaka', 20)
#getter,Rufen Sie Eigenschaften wie Variablen auf, wenn Sie Setter verwenden
human.name = 'Suzuki'
human.print_name()
** <Muster 2 (hauptsächlich dieses)> **
#getter
@property
def val_name(self):
private Variable zurückgeben
#setter
@val_name.setter
def val_name(self, val):
self.__val = val
#Verkapselung, Getter, Setter-Muster 2
class Human:
def __init__(self, name, age):
self.__name = name
self.__age = age
#Getter Definition
@property
def name(self):
print('call getter [name]')
return self.__name
@name.setter
def name(self, name):
print('call setter [name]')
self.__name = name
@property
def age(self):
print('call getter [age]')
return self.__age
@age.setter
def age(self, age):
print('call setter [age]')
if age >= 5:
print('Bitte geben Sie einen Wert von 4 oder weniger ein.')
return
else:
self.__age = age
human = Human('taro', 24)
human.name = 'goro'
human.age = 5
print(human.name)
print(human.age)
#Bibliothek für abstrakte Methoden
from abc import abstractmethod, ABCMeta
#Abstrakte Klassendefinition
class Animals(metaclass=ABCMeta):
#Kapselungsunterstützung(private Variablen, Getter, Setter)
def __init__(self, voice):
self.__voice = voice
@property
def voice(self):
return self.__voice
@voice.setter
def voice(self, voice):
self.__voice = voice
#Abstrakte Methode(Muss in der Unterklasse überschrieben werden)
@abstractmethod
def speak(self, voice):
pass
"""
Da die folgenden Unterklassen Tiere als Oberklassen erben,
Konstruktorverarbeitung, Getter, Setter sind üblich
"""
class Dog(Animals):
#self.Voice verwendet die in der Superklasse definierte Getter-Verarbeitung.
def speak(self):
print(self.voice)
class Cat(Animals):
def speak(self):
print(self.voice)
class Sheep(Animals):
def speak(self):
print(self.voice)
class Other(Animals):
def speak(self):
print(self.voice)
#Holen Sie sich Standardeingabe
select = int(input('Bitte gebe eine Nummer ein: '))
if select == 1: #Hund
animal = Dog("Hund")
elif select == 2: #Katze
animal = Cat("Miau")
elif select == 3: #Schaf
animal = Sheep("Baa")
else: #Andere
animal = Other("Es gibt kein solches Tier")
animal.speak()
filepath = 'resources/test.txt'
"""
#open,Geben Sie close an(Besser verwenden, um zu vergessen, den Hut zu schließen)
f = open(filepath, mode='r') #Datei im Lesemodus öffnen
data = f.read() #Lesen Sie den gesamten Inhalt der Datei
f.close()
print(data)
"""
#open,Automatisch schließen
#Geben Sie den Zeichencode der zu lesenden Datei mit der Codierungsoption an
with open(filepath, mode='r', encoding='utf-8') as f:
text = ''
#Lesen Sie nur eine Zeile
#print(f.readline())
#Zeile für Zeile lesen (als Array zurückgeben)
for line in f.readlines():
text += line
print(text)
filepath = 'resources/output.txt'
"""
#Geben Sie das Zeilenvorschubzeichen mit der Option Zeilenumbruch an. (Standard:\n）
f = open(filepath, mode='w', encoding='utf-8', newline='\n')
f.write('Geschrieben')
"""
list_a = [
['A','B','C'],
['Ah','ich','U.']
]
#Bei Verwendung des With-Syntax-Modus:Überschreiben Sie w, wenn eine Datei mit demselben Namen vorhanden ist.
with open(filepath, mode='w', encoding='utf-8', newline='\n') as f:
f.writelines('\n'.join(list_a[0]))
#Geben Sie die Datei im Anhänge-Modus aus. Wenn die angegebene Datei nicht vorhanden ist, erstellen Sie eine neue.
with open(filepath, mode='a', encoding='utf-8', newline='\n') as f:
f.writelines(list_a[1])
with [class] as x:
wird bearbeitet
Führen Sie vor dem Ausführen des mit beschriebenen Prozesses den folgenden in der angegebenen Klasse definierten Prozess aus.
Zusätzlich wird die folgende Verarbeitung am Ende der Klassenverarbeitung ausgeführt.
--Dateischreibvorgang (Datei öffnen → schreiben → schließen) --Schreiben Sie Daten in die DB (DB-Verbindung-> Datenregistrierung-> DB-Trennung
class WithTest:
"""
Um Ihre eigene Klasse zu einer Klasse zu machen, mit der verwendet werden kann, müssen die folgenden 3 Methoden implementiert werden.
"""
def __init__(self, file):
print('init called')
self.__file = file
def __enter__(self):
print('enter called')
self.__file = open(self.__file, mode='w', encoding='utf-8')
return self
def __exit__(self, exc_type, exc_val, traceback):
print('exit caled')
def write(self, msg):
self.__file.write(msg)
with WithTest('resources/output.txt') as wt:
print('---Innen mit--')
wt.write("Schreiben")
init called
enter called
---Innen mit--
exit caled
kekosh-mbp:flaskenv kekosh$
Recommended Posts