objets python et technologie orientée objet

Les exemples de cet article décrivent les objets Python et la technologie orientée objet. Partagez-le avec tout le monde pour votre référence, comme suit :

1 Regardons d'abord un exemple. Ce chapitre expliquera cet exemple de programme :

Fichier : fileinfo.py :

"""Framework for getting filetype-specific metadata.
Instantiate appropriate class with filename. Returned object acts like a
dictionary, with key-value pairs for each piece of metadata.
  import fileinfo
  info = fileinfo.MP3FileInfo("/music/ap/mahadeva.mp3")
  print "\n".join(["%s=%s" % (k, v) for k, v in info.items()])
Or use listDirectory function to get info on all files in a directory.
  for info in fileinfo.listDirectory("/music/ap/", [".mp3"]):
    ...
Framework can be extended by adding classes for particular file types, e.g.
HTMLFileInfo, MPGFileInfo, DOCFileInfo. Each class is completely responsible for
parsing its files appropriately; see MP3FileInfo for example.
"""
import os
import sys
from UserDict import UserDict
def stripnulls(data):
  "strip whitespace and nulls"
  return data.replace("{post.content}", "").strip()
class FileInfo(UserDict):
  "store file metadata"
  def __init__(self, filename=None):
    UserDict.__init__(self)
    self["name"] = filename
class MP3FileInfo(FileInfo):
  "store ID3v1.0 MP3 tags"
  tagDataMap = {"title"  : ( 3, 33, stripnulls),
         "artist" : ( 33, 63, stripnulls),
         "album"  : ( 63, 93, stripnulls),
         "year"  : ( 93, 97, stripnulls),
         "comment" : ( 97, 126, stripnulls),
         "genre"  : (127, 128, ord)}
  def __parse(self, filename):
    "parse ID3v1.0 tags from MP3 file"
    self.clear()
    try:
      fsock = open(filename, "rb", 0)
      try:
        fsock.seek(-128, 2)
        tagdata = fsock.read(128)
      finally:
        fsock.close()
      if tagdata[:3] == "TAG":
        for tag, (start, end, parseFunc) in self.tagDataMap.items():
          self[tag] = parseFunc(tagdata[start:end])
    except IOError:
      pass
  def __setitem__(self, key, item):
    if key == "name" and item:
      self.__parse(item)
    FileInfo.__setitem__(self, key, item)
def listDirectory(directory, fileExtList):
  "get list of file info objects for files of particular extensions"
  fileList = [os.path.normcase(f)
        for f in os.listdir(directory)]
  fileList = [os.path.join(directory, f)
        for f in fileList
        if os.path.splitext(f)[1] in fileExtList]
  def getFileInfoClass(filename, module=sys.modules[FileInfo.__module__]):
    "get file info class from filename extension"
    subclass = "%sFileInfo" % os.path.splitext(filename)[1].upper()[1:]
    return hasattr(module, subclass) and getattr(module, subclass) or FileInfo
  return [getFileInfoClass(f)(f) for f in fileList]
if __name__ == "__main__":
  for info in listDirectory("/music/_singles/", [".mp3"]):
    print "\n".join(["%s=%s" % (k, v) for k, v in info.items()])
    print

2 Utiliser from module import pour importer le module

Le module d'importation que nous avons appris auparavant utilise la syntaxe suivante :

importer le nom du module

De cette façon, lorsque vous devez utiliser des éléments dans ce module, vous devez utiliser le nom du module et utiliser directement le nom qu'il contient est une erreur. Donc, imprimez :

.

>>> import types
>>> types.FunctionType
<type>
>>> FunctionType</type>

Regardez maintenant une autre syntaxe pour importer des noms dans des modules :

from module name import name

ou utilisez

Traceback (most recent call last):
 File "<interactive>", line 1, in <module>
NameError: name 'FunctionType' is not defined</module></interactive>

à partir de l'importation du nom du module *

Par exemple :

De cette façon, le nom importé peut être utilisé directement sans le nom du module. Par exemple :

>>> from types import FunctionType

3 Définition de classe

La syntaxe pour définir une classe :

class nom de la classe :

>>> FunctionType
<type></type>

pass

ou

nom de la classe de classe (liste des classes de base) :

pass

Le pass est un mot-clé Python. Cela signifie. ne rien faire.

Une classe peut également avoir un document de classe. Si c'est le cas, cela devrait être la première chose dans la définition de la classe. Par exemple :

.

Le constructeur de la classe est :

class A(B) :
  " this is class A. "

Cependant, pour être précis, cela ne peut être considéré que comme une méthode qui est automatiquement exécuté après la création d'un objet de ce type. Lorsque cette fonction est exécutée, l'objet a été initialisé

Par exemple :

__init__

<.>Un constructeur est défini ici pour la classe A, et le constructeur de la classe de base B y est appelé

Il convient de noter qu'en Python, le constructeur de la classe dérivée ne sera pas. "automatiquement" appelé. Si nécessaire, il doit être écrit explicitement

Toutes les méthodes de classe sont utilisées pour recevoir ce pointeur.

class A(B) :
  "this is class A. "
  def __init__ (self):
    B.__init__(self)

Do. ne transmet pas ce paramètre lors de l'appel. Il sera ajouté automatiquement.

Mais dans le constructeur comme ci-dessus, appelez le __init( de la classe de base).

4. Instanciation d'une classe

L'instanciation d'une classe est similaire à d'autres langages. Il suffit d'appeler son nom de classe en tant que fonction . Il n'y a pas de nouveauté dans d'autres langages. list)

Le premier paramètre self de __init__ n'a pas besoin d'être donné dans la liste des paramètres.

Par exemple :

a = A()

Nous pouvons visualiser la documentation d'une classe ou d'une instance de classe. Ceci via leur attribut __doc__ Par exemple :

Nous pouvons également. obtenir sa classe via son instance. C'est via son attribut __class__ Par exemple :

Après avoir créé une instance de la classe. Vous devez vous soucier du recyclage. Le garbage collection détruira automatiquement les objets inutilisés en fonction du comptage des références.

>>> A.__doc__
'this is class A. '
>>> a.__doc__
'this is class A. '

En Python, il n'y a pas d'instruction de déclaration spéciale lors de l'affectation. :

>>> a.__class__
<class></class>

À ce moment, les données sont automatiquement utilisées car elles sont membres de la classe A.

est dans la définition de la classe. Pour utiliser des variables membres ou des méthodes membres dans la classe, elles doivent être qualifiées avec le nom self

Par conséquent, les données sont généralement générées Member. Attribuez simplement une valeur au nom self dans n'importe quelle méthode. .

Cependant, c'est une bonne pratique d'attribuer une valeur initiale à tous les attributs de données dans la méthode __init__

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

Python ne prend pas en charge la surcharge de fonctions

Parlons-en. indentation du code ici. En fait, si un bloc de code n'a qu'une seule phrase, il peut être placé directement après les deux points. Il n'est pas nécessaire d'envelopper le format d'indentation

6 Méthodes de classe spéciales

sont différentes des méthodes ordinaires. Après avoir défini des méthodes spéciales dans une classe, vous n'êtes pas obligé de les appeler explicitement. Au lieu de cela, Python les appellera automatiquement à certains moments.

Obtenir et définir des éléments de données.

Cela nécessite de définir les méthodes __getitem__ et __setitem__ dans la classe.

Par exemple :

Le a[1] ici appelle la méthode __getitem__. Elle est égale à a.__getitem__(1)

Similaire à la méthode __getitem__, il y a __setitem__

Par exemple, dans la classe A ci-dessus définit :

>>> class A:
... def __init__(self):
...  self.li = range(5)
... def __getitem__(self, i):
...  return self.li[-i]
...
>>> a = A()
>>> print a[1]

Appelez ensuite cette méthode comme suit :

a[1] = 0 ce qui équivaut à appeler un .__setitem__(1, 0)

7 Méthodes de classe spéciales avancées

sont similaires à __getitem__ __setitem__ Il existe également quelques fonctions spéciales spéciales :

def __setitem__(self, key, item):
  self.li[key] = item

.

Cette méthode spéciale est utilisée pour représenter la représentation sous forme de chaîne de cet objet. Elle est appelée via la fonction intégrée repr() Par exemple,

Cette repr() peut être appliquée à n'importe quel objet.

En fait, dans la fenêtre interactive, entrez simplement le nom de la variable et appuyez sur Entrée.

def __repr__(self): return repr(self.li)

Il est utilisé pour comparer si deux instances self et x sont égales. Lorsqu'on l'appelle, c'est comme suit :

repr(a)

Cela compare si a et b sont égaux. Identique à appeler a.cmp(b)

def __cmp__(self, x):
  if isinstance(x, A): return cmp(self.li, x.li)

Il est utilisé pour renvoyer la longueur de l'objet . Il sera appelé lors de l'utilisation de len (object

Utilisez-le pour spécifier une valeur de longueur logique souhaitée

a = A()
b = A()
a == b

.

In Cette fonction sera appelée lorsque l'objet del [key] est appelé.

8 Attributs de classe

def __len__(self): return len(self.li)

Les attributs de classe font référence à des éléments comme les membres statiques en c.

En Python, il peut également y avoir des attributs de classe. Par exemple :

def __delitem__(self, key): del self.li[key]

peut être référencé (modifié) via des classes. (modifié) via des instances :

ou

class A :
  l = [1, 2, 3]

9 Fonction privée

Il existe également la notion de "privé" en Python :

Les fonctions privées ne peuvent pas être appelées depuis l'extérieur de leurs modules.
Les méthodes de classe privée ne peuvent pas être appelées depuis l'extérieur de leurs classes.
Attributs privés Ils ne sont pas accessibles depuis l'extérieur de leurs classes.

Il n'y a que deux types de privé et de public en Python. Il n'y a pas de concept de protection. La distinction entre public et privé dépend des fonctions, des méthodes de classe et de l'attribut de classe. noms.

Les noms des éléments privés commencent par __. (Mais les méthodes spéciales mentionnées précédemment (telles que __getitem__) ne sont pas privées).

Pour plus d'articles liés aux objets python et aux objets- orienté technologie, faites attention au site PHP chinois !