Mit Flask erstellte SNS Python-Grundlagen

zunaechst

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.

Aufbau einer virtuellen Umgebung

Erstellen Sie eine virtuelle Umgebung zum Erstellen von Anwendungen mit venv.

1. Erstellen einer virtuellen Umgebung

(base) [email protected]:/home/venv/flaskenv# python -m venv flaskenv

2. Starten Sie die virtuelle Umgebung

-Der Name der virtuellen Umgebung, die gestartet wurde, wird mit () am Zeilenanfang angezeigt.

(base) [email protected]:/home/venv/flaskenv# source bin/activate
(flaskenv) (base) [email protected]:/home/venv/flaskenv# 

·Halt

(flaskenv) (base) [email protected]:/home/venv/flaskenv# deactivate
(base) [email protected]:/home/venv/flaskenv# 

Git Registrierung

1. Erstellen Sie ein Repository auf Github

Kürzung

2. Lokale Git-Registrierung und Github-Integration

[email protected] flaskenv % git init
Initialized empty Git repository in /Users/kekosh/work/docker/venv/flaskenv/.git/

[email protected] flaskenv % git add .

[email protected] flaskenv % git commit -m 'first commit'

[email protected] flaskenv % git remote add origin  [email protected]:kekosh/flask-sns.git

[email protected] flaskenv % git push -u origin master

Beim Ändern des Github-Repositorys (nach "remote add ....")

[email protected] flaskenv % git remote rm origin

Mac-Notizen

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.

[email protected] flaskenv % git rm -r --cached .

Python

alle (Aggregat und Bedingungen)

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

beliebig (Aggregat der OP-Bedingungen)

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

aufzählen (gleichzeitig Index abrufen)

>>> list = ['taro','jiro','sabu','shiro']
>>> for i, v in enumerate(list):
...     print(i, v)
... 
0 taro
1 jiro
2 sabu
3 shiro

zip (Werte von zwei Arrays gleichzeitig abrufen)

>>> 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

Seiuchi-Operator (Zuordnung zur Variablen und gleichzeitige Verwendung. Python3.8 oder höher)

Kürzung

Traceback importieren (Fehlerdetails abrufen)

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

Ausnahme auslösen (gibt absichtlich eine bestimmte Ausnahme zurück)

raise ZeroDivisionError('Nicht durch Null teilbar')

Erstellen Sie Ihre eigene Ausnahme

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

Argument variabler Länge

>>> 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'}

Generatorfunktion

--yield val: Stoppt die Funktionsverarbeitung bei 'yield' und gibt die Yield-Variable an den Aufrufer zurück. --Die Verarbeitung unter "Ausbeute" wird ausgeführt, indem sie als "nächste (Funktion)" bezeichnet wird.

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

Subgenerator

--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

Verwendung des Generators

Funktion höherer Ordnung

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

#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

Rekursiv

--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

Listeneinschlussnotation

--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

#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'}
******************************

Kartenfunktion

--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

Klassendefinition

#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 und Instanzvariablen

** 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$ 

Konstrukteur

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

Zerstörer

--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

Methodentyp

** 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

Spezielle Methode

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

Zusammenfassung bisher

#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.

Klassenvererbung

** 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 von Klassen

** 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

Polymorphismus

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 [email protected] 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

Private Variablen

--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

Verkapselung, Setter, Getter

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)

Zusammenfassung bisher


#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()

Dateieingabe

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)

Dateiausgabe

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])

Verwendung mit

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.

Wenn der Prozess vom Anfang bis zum Ende kontinuierlich durchgeführt wird

--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

Mit Flask erstellte SNS Python-Grundlagen
Programmieren mit Python Flask
Mattermost Bot mit Python gemacht (+ Flask)
Ich habe einen Blackjack mit Python gemacht!
Webanwendung mit Python + Flask ② ③
Ich habe mit Python einen Blackjack gemacht.
Othello gemacht mit Python (wie GUI)
Ich habe Wordcloud mit Python gemacht.
Webanwendung mit Python + Flask ④
Python-Grundlagen ⑤
Python-Grundlagen
Python-Grundlagen ④
Ich habe versucht, LINE-Bot mit Python + Flask + ngrok + LINE Messaging API zu erstellen
Numer0n mit Elementen, die mit Python erstellt wurden
Ich habe eine einfache Buch-App mit Python + Flask ~ Introduction ~ erstellt
Ich habe mit Python eine Lotterie gemacht.
Erste Schritte mit Python Grundlagen von Python
Python-Grundlagen ③
Python-Grundlagen
Othello-Spieleentwicklung mit Python
Python-Grundlagen
Python-Grundlagen
Python-Grundlagen ③
Python-Grundlagen ②
Python-Grundlagen ②
Ich habe mit Python einen Daemon erstellt
Anwendungsentwicklung mit Docker + Python + Flask
Ich habe mit Python, Flask und Heroku ein Nyanko-Tweet-Formular erstellt
Grundlagen der binärisierten Bildverarbeitung durch Python
Einfacher Slack API-Client mit Python
HTTP Split Download Typ mit Python gemacht
Ich habe mit Python einen Zeichenzähler erstellt
POST verschieden mit Python und empfange mit Flask
Erste Schritte mit Python für PHPer-Super Basics
Einfache Web-App mit Python + Flask + Heroku
[Python] Erstellen Sie schnell eine API mit Flask
Ich habe mit Python eine Hex-Map erstellt
Serverlose Gesichtserkennungs-API mit Python
Ich habe mit Python ein schurkenhaftes Spiel gemacht
Ich habe mit Python einen einfachen Blackjack gemacht
Ich habe mit Python eine Einstellungsdatei erstellt
Ich habe mit Python einen Neuronensimulator erstellt
Othello App (iOS App) erstellt mit Python (Kivy)
FizzBuzz in Python3
Python-Grundlagen: Liste
Scraping mit Python
Statistik mit Python
Scraping mit Python
Python mit Go
# Python-Grundlagen (#matplotlib)
Twilio mit Python
Python CGI-Grundlagen
Python-Grundlagen: Wörterbuch
In Python integrieren
Spielen Sie mit 2016-Python