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.
Créez un environnement virtuel pour créer des applications à l'aide de venv.
(base) root@e8cf64ce12e9:/home/venv/flaskenv# python -m venv flaskenv
-Le nom de l'environnement virtuel qui a été démarré est affiché avec () au début de la ligne.
(base) root@e8cf64ce12e9:/home/venv/flaskenv# source bin/activate
(flaskenv) (base) root@e8cf64ce12e9:/home/venv/flaskenv#
·Arrêtez
(flaskenv) (base) root@e8cf64ce12e9:/home/venv/flaskenv# deactivate
(base) root@e8cf64ce12e9:/home/venv/flaskenv#
réduction
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
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.
kekosh@kekosh-mbp flaskenv % git rm -r --cached .
Python
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
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
>>> 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
réduction
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
raise ZeroDivisionError('Non divisible par zéro')
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
>>> 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'}
--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
--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
--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
--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
>>> 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
--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'>
#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'}
******************************
--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
#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 ** --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$
--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
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
** 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
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
#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 **
** 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 ** 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
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 ci-dessous@Dé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
__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
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)
#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()
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)
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])
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.
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