Bases de SNS Python faites avec Flask

en premier

Registre de présence Udemy des cours suivants

Cours de développement d'applications Web avec Python + Flask! !! ~ Master Flask de 0 pour créer SNS ~ https://www.udemy.com/course/flaskpythonweb/

La grammaire de base de Python et la création d'application à l'aide de Flask sont décrites séparément.

Construction d'environnement virtuel

Créez un environnement virtuel pour créer des applications à l'aide de venv.

1. Créer un environnement virtuel

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

2. Démarrez l'environnement virtuel

-Le nom de l'environnement virtuel qui a été démarré est affiché avec () au début de la ligne.

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

·Arrêtez

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

Enregistrement Git

1. Créez un référentiel sur Github

réduction

2. Enregistrement local Git et intégration Github

[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

Lors de la modification du référentiel Github (après "remote add ....")

[email protected] flaskenv % git remote rm origin

Notes Mac

Pour Mac, un fichier caché appelé ".DS_Store" est créé dans chaque répertoire. Comme ce n'est pas un fichier qui devrait être géré par Git, enregistrez-le comme non géré dans gitignore avant de valider.

.gitignore


# Mac
.DS_Store

Si vous êtes déjà lié à Github, supprimez le cache Git après avoir ajouté ce qui précède à .gitignore. Rendez-le non géré lors du prochain commit.

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

Python

tous (agrégat de et conditions)

Prend une collection de plusieurs conditions de comparaison comme un tuple comme argument. Renvoie True si toutes les expressions conditionnelles sont True

>>> i = 0
>>> x = 'test'
>>> if all((i<10, x =='test')):
...     print('Tout est vrai')
... 
Tout est vrai

any (agrégat de conditions OR)

Prend une collection de plusieurs conditions de comparaison comme un tuple comme argument. Renvoie True si l'une des expressions conditionnelles est True.

>>> i = 0
>>> x = 'any'
>>> if any((i > 10, x == 'any' )):
...     print('Y compris True')
... 
Y compris True

énumérer (obtenir l'index en même temps)

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

zip (obtenir les valeurs de deux tableaux en même temps)

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

Opérateur Seiuchi (affectation à une variable et utilisation en même temps. Python3.8 ou version ultérieure)

réduction

import traceback (obtenir les détails de l'erreur)

m = 100
n = input()

try:
    result = m /int(n)
    print(result)
except ZeroDivisionError as ze:
    import traceback
    traceback.print_exc()
print('end')
#résultat
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: processus à exécuter uniquement lorsqu'aucune erreur ne se produit. L'exception qui se produit ici n'est pas interceptée par la précédente, sauf. --finalement: processus toujours exécuté indépendamment de la présence ou de l'absence d'erreur.

try:
    #Traitement principal
except XXXXXX as e:
    #Processus à exécuter lorsqu'une exception spécifique se produit
except Exception e:
    #Traitement lorsque toutes les exceptions se produisent à l'exception des exceptions qui décrivent un traitement spécifique
else:
    #Traitement exécuté uniquement lorsqu'aucune exception ne se produit
finally:
    #Traitement toujours exécuté indépendamment de la présence ou de l'absence d'exceptions

lever Exception (renvoie intentionnellement une exception spécifique)

raise ZeroDivisionError('Non divisible par zéro')

Créez votre propre exception

Créez une classe qui hérite de la classe Exception.

#modèle
class MyException(Exception)
    print('Une erreur propriétaire s'est produite')
#Exemple d'implémentation
class EvenDevideError(Exception):
    pass

def main():
    m = 10
    n = int(input('contribution:'))

    if n == 2:
        raise EvenDevideError('even number input')
    else:
        print('end')

if __name__ == '__main__':
    main()
#résultat
kekosh-mbp:flaskenv kekosh$ python main.py
Entrée: 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 de longueur variable

>>> def func_1(arg1, *arg2):
...     print("arg1={}, *arg2={}".format(arg1, arg2))
... 
>>> def func_2(arg1, **arg2):
...     print("arg1={}, **arg2={}".format(arg1, arg2))

#Si vous transmettez plusieurs valeurs"*"Définissez les valeurs une par une du début aux variables sans
#Les valeurs d'argument restantes sont collectivement définies dans arg2 comme un taple.
>>> func_1(1,2,3,4,5)
arg1=1, *arg2=(2, 3, 4, 5)

#"**"Dans le cas de, lors du passage d'une valeur, comme une variable de type dictionnaire"id=1"Dans un format comme
#Vous devez définir l'argument.
>>> 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'}

Fonction générateur

--yield val: arrête le traitement de la fonction à «rendement» et renvoie la variable de rendement à l'appelant.

def generater(max):
    print('Générer un générateur')

    for i in range(max):
        #Le traitement s'arrête à yield lors de la création d'une instance et la variable yield est renvoyée à l'appelant.
        yield i
        print('exécution de rendement')

gen = generater(10)

#next()En passant la fonction de générateur à, le traitement après yield est exécuté.
n = next(gen)
print('n = {}'.format(n))
n = next(gen)
print('n = {}'.format(n))

#next()Il est également possible d'exécuter par traitement en boucle
for x in generater(10):
    print('x = {}'.format(x))
Générer un générateur
n = 0
exécution de rendement
n = 1

--En plus de la fonction next (), la fonction de générateur a les méthodes suivantes. --send (val): Si le "rendement" dans la fonction de générateur est affecté à une variable, attribuez la valeur de val à cette variable.

def gengerator(max)
    #réduction
    for i in generator()
        x = yield i
        print(x)

gen = generator(10)
#Après avoir arrêté le traitement avec rendement, envoyer à la variable où le rendement est stocké(val)Stockez le val de.
gen.send(100)

--generator.throw (err_value): génère intentionnellement une erreur. --generator.close (): Fin du traitement du rendement

Sous-générateur

--yield du sous-générateur: une autre fonction de générateur peut être appelée à partir de la fonction de générateur.

def sub_gen():
    yield 'sub_generator'
    print('on sub_gen')
    return 'sub_gen'

def main_gen():
    yield 'main_generator'

    #Appelez le sous-générateur avec rendement de
    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

Utilisation du générateur

Fonction d'ordre supérieur

--Attribuer une fonction à une variable.

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('La valeur de retour est une fonction')

#pattern1.Fonction de stockage comme élément de liste
list = [1, 'test', print_bye, print_hello]

#pattern1.Lors de l'exécution de fonctions d'ordre supérieur, "" après l'index()"
list[2]()

#pattern2.Motif pour passer la fonction à l'argument de la fonction (la valeur de retour est également une fonction)
var = print_hello(print_bye)
var()
#Résultat de pattern1
good bye, someone

#Résultat de pattern2
hello
good bye, taro
La valeur de retour est une fonction

expression lambda

--Une fonction définie sur une ligne excluant le nom de la fonction de la fonction normale (def) (fonction anonyme)

#expression lambda dans l'instruction if
def func(x):
    response = ''

    #Instruction if normale
    if x > 5:
        response = 'large'
    else:
        response = 'small'

    return response

    #format lambda
    response = 'large' if x > 5 else 'small'
    return response

x = int(input('contribution:'))
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

Récursif

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

Notation d'inclusion de liste

--Nom de la variable = [Expression de la variable dans la liste (si expression)] --En plus du type liste, si vous définissez des parenthèses avec des parenthèses, il devient un générateur, et si vous ajoutez "tuple" avant les parenthèses, le résultat au format tapple est renvoyé. Dans le cas du type set, définissez les parenthèses sur {}. --Il est également possible d'exécuter une fonction dans la notation d'inclusion de liste et de définir le résultat comme un élément de la liste.

#Notation d'inclusion de liste pour créer une 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]
#Liste de notation d'inclusion de la création de tapple
>>> 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'>

Fonction décorateur

#Définir la fonction de décorateur
def decorator(func):
    def wrapper(*args, **kwargs):
        print('*' * 30)
        #Argument: func est défini sur un objet fonction avec un ensemble de décorateurs.
        func(*args, **kwargs)
        print('*' * 30)
    return wrapper

#La fonction avec le décorateur défini dans l'argument de la fonction de décorateur est définie et exécutée.
@decorator
def func_a(*args, **kwargs):
    print('func_Exécutez un')
    print(args)

@decorator
def func_b(*args, **kwargs):
    print('func_Exécuter b')
    print(kwargs)

func_a(1,2,3)
func_b(4,5,6,id=4,name='test')
kekosh-mbp:flaskenv kekosh$ python decorator.py
******************************
func_Exécutez un
(1, 2, 3)
******************************
******************************
func_Exécuter b
{'id': 4, 'name': 'test'}
******************************

fonction de carte

--map ([fonction], [variables passées à la fonction] ...) --Retourne le résultat du traitement en acquérant séquentiellement des éléments du type de liste, du type de dictionnaire et d'autres variables de type itératif spécifiées après le deuxième argument dans l'argument de la fonction spécifiée dans le premier argument.

#Exemple typique: type de liste comme deuxième argument
list_a = [1,2,3,4,5]
map_a = map(lambda x: x*2, list_a)

#Vérifiez le contenu de l'objet de type map avec l'instruction for
for x in map_a:
    print(x)

#Les arguments de type dictionnaire peuvent également être utilisés
person = {
    'name': 'Yamada'
    ,'age': '34'
    ,'country': 'Japan'
}

#La partie fonction peut également décrire l'expression lambda
map_b = map(lambda d : d+ ',' + person.get(d), person)
for m in map_b:
    print(m)

'''
Lors du passage de plusieurs arguments à une fonction, entre les variables d'expression de l'itérateur passées à la fonction du premier argument
Si le nombre d'éléments est différent, tronquez trop selon celui qui a le plus petit nombre d'éléments.
'''
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

Définition de classe

#Modèle de définition de classe
class className:
    """Commentaires expliquant la fonction de la classe"""
    def methodName(self,...):
        #En traitement

#Créer une instance pour utiliser la classe définie
instance = className()
#<échantillon>
#Définition de classe
class Car:
    country = 'japan'
    year = 2020
    name = 'Prius'

    #Lors de la définition d'une méthode dans une classe, assurez-vous que le premier argument de la méthode est "self".
    def print_name(self):
        print('Exécution de la méthode')
        print(self.name)

my_Car = Car()
print(my_Car.year)
my_Car.print_name()

#Utiliser une classe (instance) pour un élément de type liste
list = ['apple', 'banana', Car()]
list[2].print_name()

Variables de classe et variables d'instance

** Variables de classe ** --Variables pouvant être partagées entre les objets

** comment y accéder ** --Nom de classe. Nom de variable de classe --Nom de l'instance. \ _ \ _ Classe__. Variable de classe ** * Si \ _ \ _ class \ _ \ _ n'est pas décrit (nom de l'instance, nom de la classe), les données pouvant être acquises sont différentes de la variable de classe (la variable d'instance est acquise) **

Variable d'instance --Variations utilisées séparément pour chaque instance --Description dans la méthode

** comment y accéder ** Nom de l'instance variable

class SampleA():
    #Variable de classe
    class_val = 'class val'

    def set_val(self):
        #Variable d'instance
        self.instance_val = 'instance val'

    def print_val(self):
        print('Variable de classe:{}'.format(self.class_val))
        print('Variable d'instance:{}'.format(self.instance_val))

#Création d'instance
instance_A = SampleA()
#Invocation de la méthode d'instance
instance_A.set_val()
print(instance_A.instance_val)
instance_A.print_val()

#Sortie des variables de classe
print(SampleA.class_val)
print(instance_A.__class__.class_val)

print('---------------------')

#Créer une nouvelle instance à partir de la classe
instance_B = SampleA()
instance_B.class_val = 'change'

#Si vous modifiez la valeur d'une variable de classe d'une instance, même si vous faites référence à la variable de classe d'une autre instance
#Notez que la valeur changera.
print('instance_Variable de classe de A:{}'.format(instance_A.__class__.class_val))
print('instance_Variable de classe B:{}'.format(instance_B.__class__.class_val))
instance val
Variable de classe: classe val
Variable d'instance= instance val
class val
class val
---------------------
instance_Variable de classe A: classe val
instance_Variable de classe B: classe val
kekosh-mbp:flaskenv kekosh$ 

constructeur

--Méthodes appelées lors de la création d'une instance

class Sample:
    #constructeur
    def __init__(self, msg, name=None):
        print('Exécution du constructeur')

        #Attribuer la valeur de l'argument à la variable d'instance
        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()
#Le constructeur est automatiquement exécuté lors de la création de l'instance.
Exécution du constructeur
hello
taro

Destructeur

#Destructeur
def __del__(self):
    print('Destructor a couru')
    print('name = {}'.format(self.name))
#À la fin du traitement de l'instance (y compris en cas de suppression par le nom de l'instance de suppression)
Destructor a couru
name = taro

Type de méthode

** Méthode d'instance **

** Méthode de classe ** Une méthode qui peut être utilisée sans instanciation. Écrivez "@classmethod" directement au-dessus de la définition de méthode et définissez le premier argument sur "cls".

** Méthode statique **

class Human:

    class_name='Human'

    #constructeur
    def __init__(self, name, age):
        self.name = name
        self.age = age

    #Méthode d'instance
    def print_name_Age(self):
        print('Exécution de la méthode d'instance')
        print('name={}, age={}'.format(self.name, self.age))

    #Méthode de classe
    @classmethod
    def print_class_name(cls, msg):
        print('Exécution de la méthode de classe')
        print(cls.class_name)
        print(msg)

    #Méthode statique
    @staticmethod
    def print_msg(msg):
        print('Exécution de méthode statique')
        print(msg)

#Méthode de classe
Human.print_class_name('Bonjour')

#Méthode d'instance
human =Human('taro', 18)
human.print_name_Age()

#Méthode statique
human.print_msg('statique')
Exécution de la méthode de classe
Human
Bonjour
Exécution de la méthode d'instance
name=taro, age=18
Exécution de méthode statique
statique

Méthode spéciale

Une méthode qui est appelée lorsque vous effectuez une opération spécifique lors de l'accès à une instance

Méthode Aperçu
__str__(self) str(),print()Appelé lors de l'exécution et renvoie une chaîne
__bool__(self) Personnaliser le processus de comparaison des instructions if
__len__(self) len()Personnalisez le contenu de traitement de
__eq__(self、other) Pour l'instance==Appelé lors de l'utilisation d'un opérateur
__name__(self) Renvoie le nom de la classe
__hash__(self) Crée et renvoie une valeur de hachage à partir de la valeur passée

référence

--Document officiel https://docs.python.org/ja/3.6/reference/datamodel.html#special-method-names

#Méthode spéciale

class Human:

    #constructeur
    def __init__(self, name, age, phone):
        self.name = name
        self.age = age
        self.phone = phone

    #Méthode spéciale: impression()Renvoie le résultat du traitement suivant lorsque
    def __str__(self):
        return self.name + ":" + str(self.age)

    #Méthode spéciale: "==Personnalisez le contenu du processus de comparaison
    """
Lors de la comparaison d'instances, si le nom et le téléphone correspondent même si l'âge est différent
Renvoie True.
    """
    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__Résultat de
tanaka:18

#__eq__Si vous n'avez pas défini
False

#__eq__Si vous avez défini
True

Résumé à ce jour

#Exception unique
class CharaterAlreadyExistsException(Exception):
    pass

class AllCharacters:
    '''
Classe de gestion des informations sur les personnages
    '''
    all_characters = []
    alive_characters = []
    dead_characters = []

    @classmethod
    def character_append(cls,name):
        #Le même nom renvoie une erreur unique
        if name in cls.all_characters:
            raise CharaterAlreadyExistsException('Nom du personnage existant')

        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):
        #Enregistrer les informations de caractère dans le constructeur lors de la création d'une instance
         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)

#----Exécution de l'application-----
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)
#Résultat d'exécution
8
2
['A', 'B']
['B']
['A']
Character is Already dead.

Héritage de classe

** Héritage **

** Polymorphisme ** --Créez plusieurs sous-classes qui ont le même nom mais des contenus de traitement différents.

passer outre

Surcharge --Définissez une méthode portant le même nom que la méthode définie dans la classe parente de la sous-classe. À ce stade, si l'argument ou la valeur de retour est modifié, il sera surchargé. --Il n'y a pas de fonction appelée surcharge en python. Si vous souhaitez réaliser la même fonction que la surcharge, vous pouvez modifier le nombre d'arguments en définissant à l'avance le nombre d'arguments requis avec la valeur par défaut Aucun dans la méthode cible.

#Classe parent
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))

#Hériter de la classe Person
class Employee(Person):
    def __init__(self, name, age, number):

        #super()Utilisez pour appeler le constructeur de la classe parent.
        super().__init__(name, age)

        #Étant donné que les valeurs des propriétés suivantes sont définies dans l'appel du constructeur de la classe parent,
        #L'affectation de sous-classe à la propriété est facultative
        # self.name = name
        # self.age = age
        
        #Puisque le nombre est un élément unique de la classe Employee, il est attribué séparément.
        self.number = number

    def say_number(self):
        print('my number is {}'.format(self.number))

    #Remplacer les méthodes de classe parent
    def greeting(self):
        #Exécutez la méthode du même nom dans la classe parent
        super().greeting()
        print('I\'m employee number = {}'.format(self.number))

    #Surcharge(Une fonctionnalité introuvable dans python. L'argument par défaut peut être remplacé)
    # def greeting(self, age=None):
    #     print('Surcharge')

man = Employee('Tanaka', 34, 12345)
man.greeting()
man.say_age()
hello, Tanaka
I'm employee number = 12345
34 years old.

Héritage multiple de classes

** Héritage multiple ** Plusieurs classes peuvent être héritées en tant que classes parentes.

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

#Sous-classe héritée multiple
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',)
#Exécuter les méthodes ClassA et ClassB héritées
sample.print_a()
sample.print_b()

#Exécuter des méthodes spécifiques à la sous-classe
sample.print_new_name()

#Exécuter la méthode de superclasse à partir de la sous-classe
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

Polymorphisme

Lorsque plusieurs sous-classes sont créées, la méthode avec le même nom est-elle toujours définie et peut-elle être exécutée?

** Classe abstraite ** --Une classe qui ne crée pas (ne peut pas) créer une instance de la classe elle-même, a une méthode abstraite et est utilisée par les sous-classes comme une superclasse.

#Modèle de classe abstraite
from abc import ABCMeta, abstractmethod

class Human(metaclass=ABCMeta)

    @abstractmethod
    def say_name(self, name):
        pass

** méthode abstraite ** --Une méthode créée en déclarant "@abstractmethod" directement au-dessus de la méthode

#Classe abstraite
from abc import ABCMeta, abstractmethod

class Human(metaclass = ABCMeta):

    def __init__(self, name):
        self.name = name
    
    #Méthode abstraite
    @abstractmethod
    def say_something(self):
        pass

    def say_name(self):
        print('my name is {}.'.format(self.name))

"""
Si vous héritez de la classe abstraite comme [email protected]éclarée comme méthode abstraite
Si vous ne remplacez pas la méthode, une erreur se produira lors de la création de l'instance.

class Woman(Human):
    pass

Erreur:
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):
    #Ajouter un type d'argument avec remplacement
    def say_something(self, name='nameless', age='20'):
        print('I\'m Men.' + str(age))

#Exécution de classe abstraite
# wm = Woman('Hanako')
# me = Man("Yamada")
# wm.say_something()
# me.say_something('taro',12)

#Polymorphisme
"""
Tant qu'elle n'est pas exécutée, l'instance humaine n'est pas décidée s'il s'agit d'un homme ou d'une femme.
Peu importe si la méthode d'instance à exécuter est une instance de l'une ou l'autre des classes
Peut être exécuté
"""
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()
--Vérifiez le résultat de l'exécution de la classe abstraite--
I'm Lady.
I'm Men.12

#Si vous entrez 0
--Résultat de l'exécution du polymorphisme--
I'm Lady.

#Si vous entrez 1
--Résultat de l'exécution du polymorphisme--
I'm Men.20

Variables privées

__variable = "val"
#Lorsque vous essayez d'appeler une variable privée
AttributeError: 'Human' object has no attribute '__name'
#Accéder aux variables privées depuis une instance
val =exemple._nom de la classe__name

Encapsulation, setter, getter

Lors de l'utilisation de variables privées, il est nécessaire d'encapsuler les variables privées afin qu'elles ne puissent pas être vues de l'extérieur de la classe.

#définition getter
def get_Nom de variable():
En traitement

#Définition de setter
def set_Nom de variable();
En traitement

#getter,Créer une propriété à appeler setter
Nom de variable= property(get_Nom de variable, set_Nom de variable)

-Un nom commun est entré dans la partie "nom de variable".

** <Modèle 1> **

#Encapsulation, getter, modèle de setter 1

class Human:
    def __init__(self,name,age):
        #variable privée
        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

    #Créer une propriété (getter,Requis pour utiliser setter)
    #Utilisez la propriété lors de l'accès de l'extérieur.
    name = property(get_name, set_name)

    def print_name(self):
        print(self.__name)

human = Human('Tanaka', 20)

#getter,Appeler des propriétés comme des variables lors de l'utilisation de setter
human.name = 'Suzuki'
human.print_name()

** <Motif 2 (principalement celui-ci)> **

#getter
@property 
def val_name(self):
retourne une variable privée

#setter
@val_name.setter
def val_name(self, val):
    self.__val = val
#Encapsulation, getter, modèle de setter 2

class Human:

    def __init__(self, name, age):
        self.__name = name
        self.__age = age
    
    #définition getter
    @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('Veuillez saisir une valeur inférieure ou égale à 4.')
            return
        else:
            self.__age = age
    
human = Human('taro', 24)
human.name = 'goro'
human.age = 5
print(human.name)
print(human.age)

Résumé à ce jour


#Bibliothèque de méthodes abstraites
from abc import abstractmethod, ABCMeta

#Définition de classe abstraite
class Animals(metaclass=ABCMeta):

    #Prise en charge de l'encapsulation(variables privées, getters, setters)
    def __init__(self, voice):
        self.__voice = voice

    @property
    def voice(self):
        return self.__voice

    @voice.setter
    def voice(self, voice):
        self.__voice = voice

    #Méthode abstraite(Doit être remplacé dans la sous-classe)
    @abstractmethod
    def speak(self, voice):
        pass

"""
Puisque les sous-classes suivantes héritent des Animals en tant que superclasses,
Le traitement du constructeur, le getter, le setter sont courants
"""
class Dog(Animals):
    #self.voice utilise le traitement getter défini dans la super classe.
    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)


#Obtenez une entrée standard
select = int(input('Veuillez saisir un nombre: '))

if select == 1: #chien
    animal = Dog("Chien")
elif select == 2: #Chat
    animal = Cat("Miaou")
elif select == 3: #mouton
    animal = Sheep("Bêlement")
else: #Autre
    animal = Other("Il n'y a pas un tel animal")

animal.speak()

Entrée de fichier

filepath = 'resources/test.txt'

"""
#open,Spécifier fermer(Mieux vaut utiliser avec pour oublier de fermer le chapeau)
f = open(filepath, mode='r') #Ouvrir le fichier en mode lecture
data = f.read() #Lire tout le contenu du fichier
f.close()

print(data)
"""

#open,Fermer automatiquement
#Spécifiez le code de caractère du fichier à lire avec l'option d'encodage
with open(filepath, mode='r', encoding='utf-8') as f:
    text = ''

    #Lire une seule ligne
    #print(f.readline())

    #Lecture ligne par ligne (retour sous forme de tableau)
    for line in f.readlines():
        text += line

    print(text)

Sortie de fichier

filepath = 'resources/output.txt'

"""
#Spécifiez le caractère de saut de ligne avec l'option de nouvelle ligne. (Défaut:\n)
f = open(filepath, mode='w', encoding='utf-8', newline='\n')
f.write('Écrit')
"""

list_a = [
    ['A','B','C'],
    ['Ah','je','U']
    ]

#Lors de l'utilisation du mode avec syntaxe:écraser w si un fichier du même nom existe.
with open(filepath, mode='w', encoding='utf-8', newline='\n') as f:
    f.writelines('\n'.join(list_a[0]))

#Sortez le fichier en mode ajout. Si le fichier spécifié n'existe pas, créez-en un nouveau.
with open(filepath, mode='a', encoding='utf-8', newline='\n') as f:
    f.writelines(list_a[1])

Comment utiliser avec

with [class] as x:
En traitement

Avant d'exécuter le processus qui décrit avec, exécutez le processus suivant défini dans la classe spécifiée.

De plus, le traitement suivant est exécuté à la fin du traitement de classe.

Lorsque le processus du début à la fin est exécuté en continu
  • Processus d'écriture de fichier (fichier ouvert → écrire → fermer) --Écrire des données dans la base de données (connexion à la base de données-> enregistrement des données-> déconnexion de la base de données
class WithTest:
    """
Afin de faire de votre propre classe une classe qui peut être utilisée avec, les 3 méthodes suivantes doivent être implémentées.
    """
    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('---À l'intérieur avec--')
    wt.write("l'écriture")
init called
enter called
---À l'intérieur avec--
exit caled
kekosh-mbp:flaskenv kekosh$ 

Recommended Posts

Bases de SNS Python faites avec Flask
Programmation avec Python Flask
Made Mattermost Bot avec Python (+ Flask)
J'ai fait un blackjack avec du python!
Application Web avec Python + Flask ② ③
J'ai fait un blackjack avec Python.
Othello fait avec python (comme GUI)
J'ai créé wordcloud avec Python.
Application Web avec Python + Flask ④
Les bases de Python ⑤
Les bases de Python
Les bases de Python ④
J'ai essayé de créer LINE-bot avec Python + Flask + ngrok + LINE Messaging API
Numer0n avec des objets fabriqués avec Python
J'ai créé une application de livre simple avec python + Flask ~ Introduction ~
J'ai fait une loterie avec Python.
Premiers pas avec Python Bases de Python
Les bases de Python ③
Les bases de Python
Développement de jeux Othello avec Python
Les bases de Python
Les bases de Python
Les bases de Python ③
Les bases de Python ②
Les bases de Python ②
J'ai créé un démon avec Python
Développement d'applications avec Docker + Python + Flask
J'ai créé un formulaire de tweet Nyanko avec Python, Flask et Heroku
Bases du traitement d'images binarisées par Python
Client API Slack simple réalisé avec Python
Type de téléchargement de partage HTTP réalisé avec Python
J'ai fait un compteur de caractères avec Python
POSTER diversement avec Python et recevoir avec Flask
Premiers pas avec Python pour PHPer-Super Basics
Application Web facile avec Python + Flask + Heroku
[Python] Créez rapidement une API avec Flask
J'ai fait une carte hexadécimale avec Python
API de reconnaissance faciale sans serveur conçue avec Python
J'ai fait un jeu rogue-like avec Python
J'ai fait un simple blackjack avec Python
J'ai créé un fichier de configuration avec Python
J'ai fait un simulateur de neurones avec Python
Application Othello (application iOS) réalisée avec Python (Kivy)
FizzBuzz en Python3
bases de python: liste
Grattage avec Python
Statistiques avec python
Grattage avec Python
Python avec Go
Les bases de #Python (#matplotlib)
Twilio avec Python
Principes de base de Python CGI
bases de python: dictionnaire
Intégrer avec Python
Jouez avec 2016-Python