Quelles sont les méthodes de base d’utilisation des classes Python ?

1. Orienté objet

Class (class) : C'est une collection d'objets utilisés pour décrire les mêmes attributs et méthodes.

Variables de classe : les variables de classe sont publiques dans tout l'objet instancié. Généralement défini dans la classe et en dehors du corps de la fonction.

Méthodes : fonctions de la classe

Membres de données : les variables de classe ou variables d'instance sont utilisées pour traiter les données liées à la classe et à ses objets d'instance.

Réécriture de méthode : si la méthode héritée de la classe parent ne peut pas répondre aux besoins de la sous-classe, elle peut être réécrite. Ce processus est appelé remplacement de méthode, également appelé réécriture de méthode.

Variables locales : Les variables définies dans les méthodes n'agissent que sur la classe de l'instance actuelle.

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

Héritage : Une classe dérivée hérite des champs et des méthodes d'une 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. Tout comme nous définissons une classe de fruits, puis définissons une classe dérivée apple, qui possède certaines propriétés et méthodes de la classe fruit, ainsi que des propriétés et méthodes uniques qui sont similaires à la classe fruit. 'est-une' relation.

Instantiation : un objet spécifique d'une classe. Une classe est comme un modèle. Ce n'est qu'après l'avoir instancié dans un objet que nous pouvons y effectuer les opérations correspondantes.

Object : une instance d'une structure de données définie via une classe. Les objets incluent deux données membres (variables de classe et variables d'instance) et des méthodes.

---

2. Définition de classe

Définissez une classe :

class ClassName:....    ....    ....

Il est recommandé d'utiliser la dénomination en casse chameau pour les noms de classe, ou toutes les lettres majuscules

---

Utiliser les méthodes d'objet de classe

Prise en charge des objets de classe. deux opérations : Référence d'attribut et instanciation

Référence d'attribut : Comme d'autres syntaxes en python, obj.name

Les attributs avec __ dans la classe sont des attributs privés de la classe. Les attributs privés ne sont pas directement accessibles en dehors de la classe, comme __name.

class Fruit:#这是类的一个基本属性self.number = 100def get_number(self):                a = self.number + 100return a

f = Fruit()print('We have {0} fruits'.format(f.number))print('We have {0} fruits'.format(f.get_number()))

Résultat de sortie :

We have 100 fruitsWe have 200 fruits

---

4. Méthode de construction

Il existe une méthode spéciale nommée __init__() dans la classe Python, appelée méthode de construction. Cette méthode sera automatiquement appelée lorsque la classe est instanciée (Peut être. utilisé pour l'initialisation des attributs de classe, etc.), similaire au constructeur de classe en C++.

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

La classe définit la méthode __init__(), et l'opération d'instanciation de la classe appellera automatiquement la méthode __init__().

class Fruit:def __init__(self):                print('你已经实例化了一个对象')
f = Fruit()

Résultats de sortie

你已经实例化了一个对象

La méthode init_() peut avoir des paramètres, et les paramètres sont transmis à l'opération d'instanciation de la classe via init().

class Complex:def __init__(self,real,image):self.r = realself.i = imagedef get_complex(self):                print('complex real is %.2f , image is %.2f'%(self.r,self.i))
a = Complex(3.5,-3)a.get_complex()

Le résultat de sortie est le suivant :

complex real is 3.50 , image is -3.00

self représente une instance d'une classe, pas une classe. Il n'y a qu'une seule différence particulière entre les méthodes de classe et les fonctions ordinaires : elles doivent avoir un premier nom de paramètre supplémentaire, qui par convention est self. Mais self n’est pas un mot-clé en Python.

Je me demande si cela peut être compris de cette façon, self représente l'adresse de l'objet après avoir instancié un objet selon une classe. Un peu comme ce pointeur dans une classe C++

class Test:def prt(self):        print(self)        print(self.__class__)
t = Test()t.prt()

Résultat :

<__main__.Test object at 0x0000025EC6D45608><class &#39;__main__.Test&#39;>

---

5. Méthodes de classe

À l'intérieur de la classe, utilisez le mot-clé def pour définir une méthode Contrairement aux définitions de fonctions générales, les méthodes de classe doivent contenir des paramètres self. , et est le premier paramètre. Si vous n'avez pas besoin de self pour transmettre les paramètres, vous devez ajouter @staticmethod devant la fonction pour indiquer le résultat de sortie de la méthode statique

class Complex:def __init__(self, real=None, image=None):self.r = realself.i = image
def get_complex(self):        print('complex real is %.2f , image is %.2f' % (self.r, self.i))
    @staticmethoddef test(a, b):        print('complex real is %.2f , image is %.2f' % (a, b))

a = Complex(3.5, -3)a.get_complex()
b = Complex()b.test(3, -2)

complex real is 3.50 , image is -3.00complex real is 3.00 , image is -3.00

---

6. Inheritance

Python prend également en charge l'héritage de classe, le format est le suivant :

class Derivedclassname(Baseclassname):    ...    ...

Baseclassname (Nom de la classe de base) 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 très utile lorsque la classe de base est définie dans un autre module :

class Fruit:    def __init__(self,sweet):        self.sweetness = sweet    def describe(self):        print('Our fruit has a sweetness of %.2f'%self.sweetness)
class Apple(Fruit):#单继承，继承fruit类    def __init__(self,sweet,color):        self.color = color        Fruit.__init__(self,sweet)    def describe(self):#改写基类fruit的方法        print('Our apple has a sweetness of {0:.2f}%,and color is {1}'.format(self.sweetness,self.color))

apple = Apple(62.2,'red')apple.describe()

Sortie :

Our apple has a sweetness of 62.20%,and color is red

Héritage multiple

Python peut également hériter de plusieurs classes de base :

class Derivedclassname(basename1,basename2,...):    ...    ...    ...

Vous avez besoin faire attention au cercle L'ordre de la classe parent entre parenthèses. S'il y a le même nom de méthode dans la classe parent mais qu'il n'est pas spécifié lorsqu'il est utilisé dans la sous-classe, Python recherche de gauche à droite. n'est pas trouvé dans la sous-classe, il recherche la classe parent de gauche à droite. Contient-elle des méthodes ?

class Fruit:def __init__(self, sweet):        self.sweetness = sweetdef describe(self):        print('Our fruit has a sweetness of %.2f' % self.sweetness)

class Food:def __init__(self, uprice, num):        self.unit_price = uprice        self.number = num        self.total_price = num * upricedef cost(self):        print('You need to pay {0:.3} yuan, thank you'.format(self.total_price))

class Apple(Fruit, Food):def __init__(self, sweet, color, uprice, num):        self.color = color        Fruit.__init__(self, sweet)        Food.__init__(self, uprice, num)def describe(self):        print('Our fruit has a sweetness of {0:.2f}%,and color is {1}'.format(self.sweetness, self.color))

rrreeSortie :

Our fruit has a sweetness of 62.20%,and color is redYou need to pay 73.5 yuan, thank you

---

7、方法重写

如果父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法,如果想调用已经被覆盖的基类方法，可以用super(子类名，子类实例对象名).父类方法

class Parent_class:def Method(self):         print ('父类方法')

class Child_class(Parent_class): # 定义子类def Method(self):        print ('子类方法')

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

子类继承父类构造函数

如果在子类中需要父类的构造方法就需要显式地调用父类的构造方法，或者不重写父类的构造方法。

class A:def __init__(self, x, y):        self.x = x        self.y = y        print('pos is ({0},{1})'.format(self.x, self.y))
def xxx(self):        print('parent now')

class B(A):def xxx(self):        print('child now')

b = B(10, 3)b.xxx()

输出

pos is (10,3)child now

如果重写了__init__ 时，实例化子类，就不会调用父类已经定义的 __init__。

如果重写了__init__ 时，要继承父类的构造方法，可以使用 super 关键字super(子类，self).__init__(参数1，参数2，....)，或者父类名称.__init__(self,参数1，参数2，...)

---

8、类的私有属性

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

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)  # 报错，实例不能访问私有变量

Traceback (most recent call last):File "test.py", line 16, in <module>    print (counter.__secretCount)  # 报错，实例不能访问私有变量AttributeError: 'JustCounter' object has no attribute '__secretCount'

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

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('***', 'www.xxx.com')x.who() # 正常输出x.foo() # 正常输出x.__foo()  # 报错

输出：

'''name  :  ***url :  www.***.com这是公共方法这是私有方法Traceback (most recent call last):  File "F:\Python\Program\test.py", line 61, in <module>    x.__foo()      # 报错AttributeError: 'Site' object has no attribute '__foo''''

类的专有方法

__init__ : 构造函数，在生成对象时调用，类似C++构造函数

__del__: 析构函数，释放对象时使用，类似C++析构函数，常用在释放申请的内存空间

__repr__: 打印，转换。这个个函数就是在打印类的时候，控制类输出的字符串

class Name:def __init__(self, name):        self.name = name

print(Name('s'))

'''<__main__.Name object at 0x0000023744AFD248>'''

class Name:def __init__(self,name):        self.name = name
def __repr__(self): #控制了在打印类时候的输出          return 'Name({!r})'.format(self.name)

print(Name('s'))
'''Name('s')'''

__setitem__ : 每当属性被赋值的时候都会调用该方法，因此不能再该方法内赋值 self.name = value 会死循环

__getitem__: 当访问不存在的属性时会调用该方法

__len__: 获得长度,如果一个类表现得像一个list，要获取有多少个元素，就得用len() 函数。要让len()函数工作正常，类必须提供一个特殊方法__len__()，它返回元素的个数。

class CountList:def __init__(self, *args):        self.list = [x for x in args]        self.count = self.__len__()
def __len__(self):         return len(self.list)
def get_count(self):         return self.count

a = CountList(1, 2, 3, 4, 4, 5)print(a.get_count())print(len(a))

__cmp__: 比较运算

__call__: 函数调用

__add__: 加运算

__sub__: 减运算

class MyClass:
def __init__(self, height, weight):        self.height = height        self.weight = weight
# 两个对象的长相加，宽不变.返回一个新的类def __add__(self, others):        return MyClass(self.height + others.height, self.weight + others.weight)
# 两个对象的宽相减，长不变.返回一个新的类def __sub__(self, others):        return MyClass(self.height - others.height, self.weight - others.weight)
# 说一下自己的参数def intro(self):        print("高为", self.height, " 重为", self.weight)

def main():    a = MyClass(height=10, weight=5)    a.intro()
    b = MyClass(height=20, weight=10)    b.intro()
    c = b - a    c.intro()
    d = a + b    d.intro()

if __name__ == '__main__':    main()

'''高为 10  重为 5高为 20  重为 10高为 10  重为 5高为 30  重为 15'''

__mul__: 乘运算

__truediv__: 除运算

__mod__: 求余运算

__pow__: 乘方

同样的。类的专有方法也可以重写

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!