Classe Python (mémo d'apprentissage Python ⑦)

À propos des étendues et des espaces de noms

Espace de nom

point

• L'espace de nom est la correspondance entre les noms et les objets.
• Les attributs associés à l'espace de noms sont reliés par des points comme ʻobj.attribute`

portée

point

• La portée est la plage du texte du programme accessible directement à partir de l'espace de noms de portée.
• L'ordre de référence du scope est le suivant
• Portée avec nom local
• S'il y a une fonction entourant ↑, la portée de cette fonction
• Portée mondiale du module actuel
• La portée la plus externe est une portée avec un nom intégré
• Les affectations et les suppressions sont toujours effectuées dans la portée la plus interne, sauf si l'instruction globale est utilisée.
• Utilisez l'instruction globale pour indiquer que la variable est dans la portée globale
• minutes non locales indiquent que la variable est dans la portée entourant la portée actuelle

Exemple de portée et d'espace de noms

def scope_test():
    def do_local():
        spam = "local spam"
    def do_nonlocal():
        nonlocal spam
        spam = "nonlocal spam"
    def do_global():
        global spam
        spam = "global spam"
    spam = "test spam"
    
    do_local()
    print("After local assignment:", spam)
    # After local assignment: test spam
    
    do_nonlocal()
    print("After nonlocal assignment:", spam)
    # After nonlocal assignment: nonlocal spam
    
    do_global()
    print("After global assignment:", spam)
    # After global assignment: nonlocal spam

scope_test()
print("In global scope:", spam)
# In global scope: global spam

Définition de classe

Syntaxe de la définition de classe

Définition de classe

class className:
    <Phrase 1>
    .
    .
    .
    <Phrase N>

point

• Lorsque vous entrez la définition de classe, un nouvel espace de noms sera créé Utilisé comme une portée locale (les variables locales, les fonctions locales sont dans cette portée)
• Lorsque la définition de classe finit de s'exécuter, un objet de classe est créé (en gros, il s'agit simplement d'un wrapper qui enveloppe l'espace de noms).

Objet de classe

point

• Les objets de classe prennent en charge deux types d'opérations: la référence d'attribut et l'instanciation.
• La référence d'attribut se fait sous la forme de ʻobj.name`
• Les références d'attribut sont tous les noms qui existent dans l'espace de noms de classe (MyClass.i et MyClass.f sont valides dans les cas suivants)

Référence d'attribut

class MyClass:
    """A simple example class"""
    i = 12345
    def f(self):
        return 'hello world'

• L'instanciation de classe est appelée comme une fonction

Instanciation de classe

x = MyClass()

• À ce stade, si la méthode __init __ () est définie, __init () __ sera automatiquement appelée pour l'instance nouvellement créée.

__init__()une fonction

    def __init__(self):
        self.data = []

• Des arguments peuvent être donnés à la fonction __init __ ()
• L'argument donné au moment de l'instanciation de la classe est utilisé comme argument

Instanciation de classe(Avec argument)

class Human:
    def __init__(self, height, weight):
        self.height = height
        self.weight = weight

x = Human(165, 55)
print('height:', x.height, 'weight:', x.weight)
# height: 165 weight: 55

Objet d'instance

point

• L'instance a deux références d'attribut, "Attribut de données" et "Méthode"

Référence des attributs de données et des méthodes

class MyClass:
    def __init__(self):
        pass
    def f(self, word):
        print(word)
        
x = MyClass()

#Ajouter / référencer des attributs de données
x.counter = 1 #Les attributs de données n'ont pas besoin d'être déclarés à l'avance
while x.counter < 10:
    x.counter = x.counter * 2
print(x.counter) # 16
del x.counter

#Référence de la méthode
x.f("hello kawauso")

Objet de méthode

• Les méthodes peuvent être stockées dans des variables
• La caractéristique de la méthode est que l'objet de l'instance est passé comme premier argument.
• Les appels à x.f () sont équivalents à MyClass.f (x)

Stocker l'objet de méthode dans une variable

xf = x.f
xf('hello kawauso again') #production: hello kawauso again

Variables de classe et variables d'instance

point

• Il existe des variables de classe communes à la classe et des variables d'instance uniques à chaque instance.
• Ne créez pas de variables de classe qui doivent être modifiées pour chaque instance.

Exemples de variables de classe et d'instance

class Dog:
    
    kind = 'Shiba' #Variable de classe
    
    def __init__(self, name):
        self.name = name #Variable d'instance
        
        
taro = Dog('Taro')
jiro = Dog('Jiro')

#Référence aux variables de classe
print(taro.kind) #Shiba
print(jiro.kind) #Shiba

#Référence aux variables d'instance
print(taro.name) #Taro
print(jiro.name) #Jiro

Divers autres

point

• Les attributs de données remplaceront la méthode avec le même nom, évitez donc les noms en double avec des conventions de dénomination, etc.
• Les attributs de données peuvent être manipulés de n'importe où (non cachés par classe)
• Le premier argument de la méthode est habituellement self (pas un mot réservé, mais tout le monde y est habitué)
• La portée globale d'une méthode est le module dans lequel la méthode est définie (la classe n'est jamais utilisée comme une portée globale)
• Bien entendu, les fonctions et modules importés dans la portée globale peuvent également être utilisés.
• La classe de méthode elle-même est également définie dans la portée globale, elle peut donc être référencée.

Héritage

Héritage de classe

point

• L'héritage transmet le nom de la classe de base comme argument de la classe
• Peut être passé d'un autre module

Échantillon d'héritage

class base():
    def a(self):
        print('Je base.est un.base.Appeler b')
        self.b()
    def b(self):
        print('Je base.b.der.Remplacé par b')

class der(base):
    def b(self):
        print('Je der.b.')


b = base()
d = der()

b.a()
#Je base.est un.base.Appeler b
#Je base.b.der.Remplacé par b

d.a()
#Je base.est un.base.Appeler b
#Je der.b.

• Utilisez la fonction intégrée ʻis instance (obj, int) `pour vérifier le type d'instance
• Utilisez ʻissubclass () `pour vérifier l'héritage de classe

Héritage multiple

point

• Python permet la définition de classe avec plusieurs classes de base

• Il semble y avoir du volume, donc je vais résumer cela séparément

Variables privées

point

• Python n'a pas de variables d'instance privées qui ne sont accessibles que depuis l'intérieur de l'objet
• Par convention, les noms précédés de «_» sont des parties privées de l'API
• Pour les membres privés de classe, il existe un mécanisme appelé mandaring de nom pour éviter les conflits de nom avec les sous-classes.
• Ceci remplace tous les identifiants de la forme «__spam» par la forme de «_classname__spam»

Exemple de mandaring de nom

class Mapping:
    def __init__(self, iterable):
        self.items_list = []
        self.__update(iterable)

    def update(self, iterable):
        for item in iterable:
            self.items_list.append(item)

    __update = update #↑ mise à jour()Copie privée de la méthode

class MappingSubclass(Mapping):
    # update()Tout en offrant une nouvelle signature de
    #Existant__init__()Peut être utilisé sans détruire
    def update(self, iterable):
        for item in zip(keys, values):
            self.items_list.append(item)

Autres choses

• Utilisez une définition de classe vide pour remplir les éléments de données nommés

class Employee:
    pass

john = Employee()

john.name = 'Jhon Doe'
john.dept = 'computer lab'
john.salary = 1000

• Il est courant de transmettre une classe qui émule une méthode d'un type de données particulier au code Python qui suppose ce type de données. Par exemple, si vous définissez une méthode read () ou readline () dans une classe qui récupère les données d'un tampon de chaîne, vous pouvez la passer comme argument à une fonction qui reçoit et formate les données d'un objet fichier.
• Les objets de méthode d'instance ont également des attributs. Pour la méthode «m ()», l'objet d'instance est «m .__ self__» et l'objet fonction correspondant à la méthode est «m .__ func__».

Les exceptions sont aussi des classes

point

• Les exceptions définies par l'utilisateur sont également des classes, vous pouvez donc les utiliser pour créer un système d'exception hiérarchique extensible.

Itérateur

point

• L'instruction for appelle en interne ʻiter () `sur l'objet conteneur.
• L'objet itérateur a __next__ (), qui lève une exception StopIteration lorsque les éléments sont épuisés, et la boucle for se termine là-dessus.
• Afin d'ajouter un comportement de répéteur à votre propre classe, vous pouvez utiliser ce mécanisme et définir comme suit.

__iter__()Quand__next__()

# __next__()Renvoie un objet avec une méthode__iter__()Définir une méthode
#Déjà__next()__Dans la classe définie par__iter__()Reviens toi-même
class Reverse:
    def __init__(self, data):
        self.data = data
        self.index = len(data)
    def __iter__(self):
        return self
    def __next__(self):
        if self.index == 0:
            raise StopIteration
        self.index = self.index - 1
        return self.data[self.index]

rev = Reverse('spam')
iter(rev)

for char in rev:
    print(char)

# m
# a
# p
# s

Générateur

point

• Generator est un outil simple pour créer des itérateurs
• Écrivez comme une fonction normale, mais utilisez yield dans la partie qui renvoie les données
• Chaque fois que next () est appelé, le générateur revient là où il s'était arrêté la dernière fois.
• Le générateur génère automatiquement les méthodes __iter__ () et __next__ (), il est donc facile de générer des itérateurs.
• Le générateur enregistre automatiquement les variables locales et l'état d'exécution entre les appels
• Le générateur envoie automatiquement une itération d'arrêt une fois terminé

Exemple de générateur

def reverse(data):
    for index in range(len(data)-1, -1, -1):
        yield data[index]

for char in reverse('golf'):
    print(char)

# f
# l
# o
# g

Type de générateur

point

• S'il s'agit d'un simple générateur, utilisez () pour l'appliquer facilement.

Exemple d'expression de générateur

sum(i*i for i in range(10)) #Total au carré

xvec = [10, 20, 30]
yvec = [7, 5, 3]
sum(x*y for x,y in zip(xvec, yvec)) #produit intérieur

from math import pi, sin
#table des péchés
sine_table = {x: sin(x*pi/180) for x in range(0, 91)}

#Mots uniques sur la page
unique_words = set(word for line in page for word in line.split())

#Président des anciens
valedictorian = max((student.gpa, student.name) for student in graduates)

data = 'golf'
list(data[i] for i in rage(len(data)-1, 1, -1))