Comment utiliser les classes et les méthodes en Python

Concepts et exemples de classes et de méthodes

• Class (Class) : Utilisé pour décrire une collection d'objets avec les mêmes propriétés et méthodes. Il définit les propriétés et méthodes communes à chaque objet de la collection. Les objets sont des instances de classes.

• Méthode : Fonction définie dans la classe.

• Constructeur de classe __init__() : La classe a une méthode spéciale (constructeur) appelée init(), qui est automatiquement appelée lorsque la classe est instanciée.

• Variable d'instance : Dans la déclaration d'une classe, les attributs sont représentés par des variables. Ces variables sont appelées variables d'instance. Une variable d'instance est une variable modifiée avec self.

• Instantiation : Créer une instance d'une classe, un objet spécifique de la classe.

• Héritage : Autrement dit, une classe dérivée hérite des champs et des méthodes de la classe de base. L'héritage permet également à un objet d'une classe dérivée d'être traité comme un objet de classe de base. Par exemple, il existe une telle conception : un objet de type Dog est dérivé de la classe Animal, qui simule la relation "est-un" (par exemple, Dog est un animal).

1. Classe Python : classe

La classe (classe) de Python est équivalente à une famille composée de plusieurs fonctions S'il y a une personne nommée f dans cette famille Myclass, si cette f a pour fonction d'imprimer la météo, alors. Si un jour j'ai besoin de ce f pour imprimer la météo du jour, alors je dois appeler son nom complet MyClass.f avant qu'il puisse me l'imprimer. Autrement dit, lorsque je l'appelle, je dois apporter son nom de famille + son nom.

• Attributs : Les attributs sont des variables dans cette classe. Si la variable est un élément, alors les différents attributs sont des éléments différents dans cette grande famille

• Méthode : La méthode est la fonction dans cette classe. Si les fonctions sont des personnes, alors différentes méthodes sont différentes personnes dans cette grande famille.

Instance MyClass :

#Myclass家族，但是这个家族只有一个人f
class MyClass:   
  """一个简单的类实例"""    
  i = 12345    
  def f(self):        
    return 'hello world'
# 实例化类
x = MyClass() 
# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i) #家族x + 物品名i
print("MyClass 类的方法 f 输出为：", x.f()) #家族x + 人名f

Résultat de sortie :

2. Méthode de construction de classe __init__()__init__()

假如init()也是人，但是他是家族和外界联络员，当外界的人想调用自己家族的人，就必须要先告诉他，所以只要家族的人被调用，那么init()就会被先执行，然后由他去告诉那个被调用的人，执行被调用的。

init()实例：

class Complex:
    def __init__(self, realpart, imagpart): #必须要有一个self参数，
        self.r = realpart
        self.i = imagpart
x = Complex(3.0, -4.5)
print(x.r, x.i)   # 输出结果：3.0 -4.5

输出结果：

3.类中方法的参数self

Si init() est aussi un humain, mais il C'est la liaison entre la famille et le monde extérieur. Lorsqu'une personne de l'extérieur veut appeler quelqu'un de sa propre famille, elle doit d'abord le lui dire. Par conséquent, tant qu'une personne de la famille est appelée, init() sera exécuté en premier. , puis il le dira à la personne appelée. La personne dont l'exécution est appelée.

Exemple init() :

• #类定义
  class people:
      #定义基本属性
      name = ''
      age = 0
      #定义私有属性,私有属性在类外部无法直接进行访问
      #定义构造方法
      def __init__(self,n,a):
          self.name = n
          self.age = a
      def speak(self):
          print("%s 说: 我 %d 岁。" %(self.name,self.age))
  
  # 实例化类
  p = people('Python',10,30)
  p.speak()

  Résultat de sortie :

• 

  3. Paramètres des méthodes dans la classe self

  Dans la classe, utilisez le mot-clé def pour définir une méthode différente de la méthode générale. définitions de fonction, la méthode de classe doit contenir le paramètre self, et c'est le premier paramètre Self qui représente une instance de la classe.

self

 : Il n'y a qu'une seule différence particulière entre les méthodes de classe et les fonctions ordinaires : il doit y avoir un premier nom de paramètre supplémentaire, et par convention son nom est self.

Instances de classes : appliquez la classe dans des scénarios d'instance. Par exemple, la fonction dans une classe est f Si ce f a la capacité d'imprimer les conditions météorologiques à un certain moment, alors si j'ai besoin de ce f. Imprimons la météo à 12 heures aujourd'hui. Ensuite, l'action de le laisser imprimer la météo à 12 heures aujourd'hui est l'instanciation de la classe, transformant les capacités des fonctions de la classe en actions réelles.

Instance d'instanciation

 :

• class [子类]([父类]):

  Résultat de sortie :

• 4. Supposons qu'il y ait deux familles, une famille A a commencé à décliner et une autre famille émergente B veut hériter de The. Les matériaux et les serviteurs de la famille A peuvent être hérités de la manière suivante. Ici, la famille A est la classe parent et la famille B est la classe enfant. En termes d'utilisation, si la famille B peut utiliser les objets et les serviteurs de la famille A à volonté.

  class [子类]([父类]1, [父类]2, [父类]3):

BaseClassName (le nom de la classe de base dans l'exemple) doit être défini dans la même portée que la classe dérivée. En plus des classes, vous pouvez également utiliser des expressions, ce qui est utile lorsque la classe de base est définie dans un autre module.

Python prend également en charge l'héritage multiple

, ce qui signifie que vous pouvez hériter de plusieurs classes parents. La méthode d'héritage est la même que la méthode d'héritage unique. La méthode est la suivante :

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))

#单继承示例
class student(people): #student为子类，people为父类
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))

s = student('ken',10,60,3)
s.speak()

🎜🎜Instance d'héritage : 🎜🎜

class Parent:        # 定义父类
   def myMethod(self):
      print('调用父类方法')

class Child(Parent): # 定义子类
   def myMethod(self):
      print('调用子类方法')

c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法

🎜🎜Résultat d'exécution : 🎜🎜🎜🎜🎜

5.方法重写

如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法。即如果B家族继承了A家族，但是B家族有个佣人只会扫地，于是A家族给这个人洗脑，让他啥都不会，然后再教这个佣人洗碗、擦桌子的技能，那么这个佣人就只会洗碗和擦桌子了。

• super()函数是用于调用父类(超类)的一个方法。

 方法重写实例：

class Parent:        # 定义父类
   def myMethod(self):
      print('调用父类方法')

class Child(Parent): # 定义子类
   def myMethod(self):
      print('调用子类方法')

c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法

输出结果：

类的特殊属性与方法

类的私有属性

• _private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

 私有属性实例：

class JustCounter:
    __secretCount = 0  # 私有变量
    publicCount = 0    # 公开变量

    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print(self.__secretCount)

counter = JustCounter()
counter.count()
counter.count()
print(counter.publicCount)
print(counter.__secretCount)  # 报错，实例不能访问私有变量

输出结果：

类的私有方法

• __private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用。self.__private_methods。

 私有方法实例：

class Site:
    def __init__(self, name, url):
        self.name = name       # public
        self.__url = url   # private

    def who(self):
        print('name  : ', self.name)
        print('url : ', self.__url)

    def __foo(self):          # 私有方法
        print('这是私有方法')

    def foo(self):            # 公共方法
        print('这是公共方法')
        self.__foo()

x = Site('Python', 'www.irvingao.com')
x.who()        # 正常输出
x.foo()        # 正常输出
x.__foo()      # 报错

输出结果：

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!